def transform(request, name):
try:
data_set = DataSet.objects.get(name=name)
except DataSet.DoesNotExist:
error = {
'status': 'error',
'message': "No Data Set named '{}' exists".format(name)
}
logger.warn(error)
error["errors"] = [create_error(request, 404, detail=error['message'])]
return HttpResponseNotFound(to_json(error))
data_set_transforms = Transform.objects.filter(
input_group=data_set.data_group, input_type=data_set.data_type)
data_type_transforms = Transform.objects.filter(
input_group=None, input_type=data_set.data_type)
transforms = data_set_transforms | data_type_transforms
serialized_transforms = [TransformView.serialize(t) for t in transforms]
return HttpResponse(to_json(serialized_transforms),
content_type='application/json')
def forbidden(request, message):
doc = {
'status': 'error',
'message': 'Forbidden: {}'.format(message),
}
doc["errors"] = [create_error(request, 403, detail=doc["message"])]
return HttpResponseForbidden(to_json(doc))
def unauthorized(request, message):
doc = {
'status': 'error',
'message': 'Unauthorized: {}'.format(message),
}
doc["errors"] = [create_error(request, 401, detail=doc["message"])]
response = HttpResponse(to_json(doc), status=401)
response['WWW-Authenticate'] = 'Bearer'
return response
def error_response(request, dashboard_slug):
error = {
'status': 'error',
'message': "No dashboard with slug '{}' exists".format(dashboard_slug)
}
logger.warn(error)
error["errors"] = [create_error(request, 404, detail=error['message'])]
return HttpResponseNotFound(to_json(error),
content_type='application/json')
def detail(user, request, email):
try:
backdrop_user = BackdropUser.objects.get(email=email)
except BackdropUser.DoesNotExist:
error = {
'status': 'error',
'message': "No user with email address '{}' exists".format(email)
}
logger.warn(error)
error["errors"] = [create_error(request, 404, detail=error['message'])]
return HttpResponseNotFound(to_json(error))
json_str = to_json(backdrop_user.serialize())
return HttpResponse(json_str, content_type='application/json')
def dashboard(user, request, name):
try:
data_set = DataSet.objects.get(name=name)
except DataSet.DoesNotExist:
error = {
'status': 'error',
'message': "No Data Set named '{}' exists".format(name)
}
logger.warn(error)
error["errors"] = [create_error(request, 404, detail=error['message'])]
return HttpResponseNotFound(to_json(error))
modules = data_set.module_set.distinct('dashboard')
dashboards = [m.dashboard for m in modules]
json_str = to_json([d.serialize() for d in dashboards])
return HttpResponse(json_str, content_type='application/json')
def dashboard(user, request, identifier=None):
def add_module_and_children_to_dashboard(dashboard,
module_data,
parent=None):
modules = []
module = add_module_to_dashboard(dashboard, module_data, parent)
modules.append(module)
for module_data in module_data['modules']:
modules.extend(
add_module_and_children_to_dashboard(dashboard, module_data,
module))
return modules
if request.method == 'GET':
if is_uuid(identifier):
return get_dashboard_by_uuid(request, identifier)
else:
return get_dashboard_by_slug(request, identifier)
data = json.loads(request.body)
# create a dashboard if we don't already have a dashboard slug
if identifier is None and request.method == 'POST':
dashboard = Dashboard()
else:
if is_uuid(identifier):
dashboard = get_object_or_404(Dashboard, id=identifier)
else:
dashboard = get_object_or_404(Dashboard, slug=identifier)
if data.get('organisation'):
if not is_uuid(data['organisation']):
error = {
'status':
'error',
'message':
'Organisation must be a valid UUID',
'errors': [
create_error(request,
400,
detail='Organisation must be a valid UUID')
],
}
return HttpResponseBadRequest(to_json(error))
try:
organisation = Node.objects.get(id=data['organisation'])
dashboard.organisation = organisation
except Node.DoesNotExist:
error = {
'status':
'error',
'message':
'Organisation does not exist',
'errors': [
create_error(request,
404,
detail='Organisation does not exist')
]
}
return HttpResponseBadRequest(to_json(error))
for key, value in data.iteritems():
if key not in ['organisation', 'links']:
setattr(dashboard, key.replace('-', '_'), value)
try:
dashboard.full_clean()
except ValidationError as error_details:
errors = error_details.message_dict
error_list = [
'{0}: {1}'.format(field, ', '.join(errors[field]))
for field in errors
]
formatted_errors = ', '.join(error_list)
error = {
'status':
'error',
'message':
formatted_errors,
'errors': [
create_error(request, 400, title='validation error', detail=e)
for e in error_list
]
}
return HttpResponseBadRequest(to_json(error))
try:
dashboard.save()
except IntegrityError as e:
error = {
'status':
'error',
'message':
'{0}'.format(e.message),
'errors': [
create_error(request,
400,
title='integrity error',
detail=e.message)
]
}
return HttpResponseBadRequest(to_json(error))
if 'links' in data:
for link_data in data['links']:
if link_data['type'] == 'transaction':
link, _ = dashboard.link_set.get_or_create(
link_type='transaction')
link.url = link_data['url']
link.title = link_data['title']
link.save()
else:
dashboard.link_set.create(link_type=link_data.pop('type'),
**link_data)
if 'modules' in data:
module_ids = set([m.id for m in dashboard.module_set.all()])
for module_data in data['modules']:
try:
modules = add_module_and_children_to_dashboard(
dashboard, module_data)
for m in modules:
module_ids.discard(m.id)
except ValueError as e:
error = {
'status': 'error',
'message': e.message,
'errors': [create_error(request, 400, detail=e.message)]
}
return HttpResponseBadRequest(to_json(error))
Module.objects.filter(id__in=module_ids).delete()
return HttpResponse(to_json(dashboard.serialize()),
content_type='application/json')