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 users(user, request, dataset_name):
users = User.objects.filter(data_sets__name=dataset_name)
if users:
json_str = to_json([u.api_object() for u in users])
else:
json_str = to_json([])
return HttpResponse(json_str, content_type='application/json')
def users(user, request, dataset_name):
users = User.objects.filter(
data_sets__name=dataset_name
)
if users:
json_str = to_json(
[u.api_object() for u in users]
)
else:
json_str = to_json([])
return HttpResponse(json_str, content_type='application/json')
def test_put_404_when_user_not_in_data_source_ownership_array(self):
collector = CollectorFactory()
collector_user, _ = User.objects.get_or_create(
email='*****@*****.**')
collector.owners.add(collector_user)
data_source = DataSourceFactory()
data_source_user, _ = User.objects.get_or_create(
email='*****@*****.**')
data_source.owners.add(data_source_user)
collector_update = {
"slug": collector.slug,
"type_id": collector.type.id,
"data_source_id": data_source.id,
"data_set": {
"data_type": collector.data_set.data_type.name,
"data_group": collector.data_set.data_group.name
}
}
response = self.client.put(
'/collector/{}'.format(collector.slug),
data=to_json(collector_update),
HTTP_AUTHORIZATION='Bearer correct-token',
content_type='application/json')
assert_that(response.status_code, equal_to(404))
def single_dashboard_for_spotlight(request, dashboard_slug):
start = time.time()
logger.info('fetching dashboard')
dashboard = fetch_dashboard(dashboard_slug)
fetch_time = time.time()
fetch_elapsed = fetch_time - start
logger.info('fetching dashboard took {}'.format(
fetch_elapsed), extra={'elapsed_time': fetch_elapsed})
if not dashboard:
return error_response(request, dashboard_slug)
dashboard_json = dashboard.spotlightify(dashboard_slug)
spotlightify_time = time.time()
spotlightify_elapsed = spotlightify_time - start
logger.info('spotlightifying dashboard took {}'.format(
spotlightify_elapsed), extra={'elapsed_time': spotlightify_elapsed})
if not dashboard_json:
return error_response(request, dashboard_slug)
json_str = to_json(dashboard_json)
response = HttpResponse(json_str, content_type='application/json')
response['Access-Control-Allow-Origin'] = '*'
if dashboard.published:
response['Cache-Control'] = 'max-age=300'
else:
response['Cache-Control'] = 'no-cache'
return response
def test_post(self):
collector = {
"slug": "some-collector",
"type_id": self.collector_type.id,
"data_source_id": self.data_source.id,
"data_set": {
"data_type": self.data_set.data_type.name,
"data_group": self.data_set.data_group.name
}
}
resp = self.client.post(
'/collector',
data=to_json(collector),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
expected_collector_name = "{} {} {}".format(
self.collector_type.name, self.data_set.data_group.name,
self.data_set.data_type.name)
assert_that(resp.status_code, equal_to(200))
resp_json = json.loads(resp.content)
assert_that(resp_json, has_key('id'))
assert_that(resp_json['slug'], equal_to("some-collector"))
assert_that(resp_json['name'], equal_to(expected_collector_name))
assert_that(resp_json['data_source']['name'],
equal_to(self.data_source.name))
assert_that(resp_json['data_set']['data_type'],
equal_to(self.data_set.data_type.name))
assert_that(resp_json['data_set']['data_group'],
equal_to(self.data_set.data_group.name))
def test_put(self):
collector = CollectorFactory()
data_source = DataSourceFactory(provider=collector.type.provider)
collector_update = {
"slug": collector.slug,
"type_id": collector.type.id,
"data_source_id": data_source.id,
"data_set": {
"data_type": collector.data_set.data_type.name,
"data_group": collector.data_set.data_group.name
}
}
response = self.client.put(
'/collector/{}'.format(collector.slug),
data=to_json(collector_update),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(200))
resp_json = json.loads(response.content)
assert_that(resp_json['data_source']['name'],
equal_to(data_source.name))
def test_put_404_when_user_not_in_data_source_ownership_array(self):
collector = CollectorFactory()
collector_user, _ = User.objects.get_or_create(
email='*****@*****.**')
collector.owners.add(collector_user)
data_source = DataSourceFactory()
data_source_user, _ = User.objects.get_or_create(
email='*****@*****.**')
data_source.owners.add(data_source_user)
collector_update = {
"slug": collector.slug,
"type_id": collector.type.id,
"data_source_id": data_source.id,
"data_set": {
"data_type": collector.data_set.data_type.name,
"data_group": collector.data_set.data_group.name
}
}
response = self.client.put('/collector/{}'.format(collector.slug),
data=to_json(collector_update),
HTTP_AUTHORIZATION='Bearer correct-token',
content_type='application/json')
assert_that(response.status_code, equal_to(404))
def single_dashboard_for_spotlight(request, dashboard_slug):
start = time.time()
logger.info('fetching dashboard')
dashboard = fetch_dashboard(dashboard_slug)
fetch_time = time.time()
fetch_elapsed = fetch_time - start
logger.info('fetching dashboard took {}'.format(fetch_elapsed),
extra={'elapsed_time': fetch_elapsed})
if not dashboard:
return error_response(request, dashboard_slug)
dashboard_json = dashboard.spotlightify(dashboard_slug)
spotlightify_time = time.time()
spotlightify_elapsed = spotlightify_time - start
logger.info(
'spotlightifying dashboard took {}'.format(spotlightify_elapsed),
extra={'elapsed_time': spotlightify_elapsed})
if not dashboard_json:
return error_response(request, dashboard_slug)
json_str = to_json(dashboard_json)
response = HttpResponse(json_str, content_type='application/json')
response['Access-Control-Allow-Origin'] = '*'
if dashboard.published:
response['Cache-Control'] = 'max-age=300'
else:
response['Cache-Control'] = 'no-cache'
return response
def test_put(self):
collector = CollectorFactory()
data_source = DataSourceFactory(provider=collector.type.provider)
collector_update = {
"slug": collector.slug,
"type_id": collector.type.id,
"data_source_id": data_source.id,
"data_set": {
"data_type": collector.data_set.data_type.name,
"data_group": collector.data_set.data_group.name
}
}
response = self.client.put(
'/collector/{}'.format(collector.slug),
data=to_json(collector_update),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(200))
resp_json = json.loads(response.content)
assert_that(resp_json['data_source']['name'],
equal_to(data_source.name))
def test_post_with_non_existent_data_set_fails(self):
data_set = {
"data_type": "some-data-type",
"data_group": "some-data-group"
}
collector = {
"slug": "some-collector",
"type_id": self.collector_type.id,
"data_source_id": self.data_source.id,
"data_set": data_set
}
response = self.client.post(
'/collector',
data=to_json(collector),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(400))
resp_json = json.loads(response.content)
assert_that(
resp_json['message'],
equal_to(
"No data set with data group '{}' and data type '{}' found"
"".format(data_set['data_group'], data_set['data_type'])))
def test_create_dashboard_ok_with_modules(self):
module_type = ModuleTypeFactory()
def make_module(slug, title, order):
return {
'slug': slug,
'title': title,
'type_id': module_type.id,
'description': 'a description',
'info': [],
'options': {},
'order': order,
'modules': [],
}
data = self._get_dashboard_payload()
data['modules'] = [
make_module('foo', 'The Foo', 1),
make_module('bar', 'The Bar', 4),
make_module('monkey', 'The the', 2),
]
data['modules'][2]['modules'] = [make_module('chimp', 'Ooh', 3)]
resp = self.client.post(
'/dashboard', to_json(data),
content_type="application/json",
HTTP_AUTHORIZATION='Bearer correct-token')
assert_that(resp.status_code, equal_to(200))
dashboard = Dashboard.objects.first()
assert_that(dashboard.module_set.count(), equal_to(4))
nested_module = Module.objects.get(slug='chimp')
assert_that(nested_module.parent.slug, equal_to('monkey'))
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 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 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 test_post_from_unauthorised_client_fails(self):
data_source = {
"name": "some-data-source",
"slug": "some-data-source",
"provider": self.provider.id
}
resp = self.client.post('/data-source',
data=to_json(data_source),
content_type='application/json')
assert_that(resp.status_code, equal_to(403))
def dashboards_by_tx(request, identifier):
dashboards = Dashboard.objects.by_tx_id(identifier)
serialized_dashboards = \
[dashboard.serialize() for dashboard in dashboards]
return HttpResponse(
to_json(serialized_dashboards),
content_type='application/json',
status=200
)
def dashboard(user, request, name):
try:
data_set = DataSet.objects.get(name=name)
except DataSet.DoesNotExist:
message = "No Data Set named '{}' exists".format(name)
return create_http_error(404, message, request, logger=logger)
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 test_post_from_unauthorised_client_fails(self):
collector_type = {
"slug": "some-collector-type",
"name": "some-collector-type",
"entry_point": "some.collector.type",
"provider": self.provider.id
}
resp = self.client.post('/collector-type',
data=to_json(collector_type),
content_type='application/json')
assert_that(resp.status_code, equal_to(403))
def dashboard(user, request, name):
try:
data_set = DataSet.objects.get(name=name)
except DataSet.DoesNotExist:
message = "No Data Set named '{}' exists".format(name)
return create_http_error(404, message, request, logger=logger)
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 test_post_from_unauthorised_client_fails(self):
data_source = {
"name": "some-data-source",
"slug": "some-data-source",
"provider": self.provider.id
}
resp = self.client.post(
'/data-source',
data=to_json(data_source),
content_type='application/json')
assert_that(resp.status_code, equal_to(403))
def test_post_from_unauthorised_client_fails(self):
collector_type = {
"slug": "some-collector-type",
"name": "some-collector-type",
"entry_point": "some.collector.type",
"provider": self.provider.id
}
resp = self.client.post(
'/collector-type',
data=to_json(collector_type),
content_type='application/json')
assert_that(resp.status_code, equal_to(403))
def test_post_from_unauthorised_client_fails(self):
collector = {
"slug": "some-collector",
"type_id": self.collector_type.id,
"data_source": self.data_source.id,
"data_set": {
"data_type": self.data_set.data_type.name,
"data_group": self.data_set.data_group.name
}
}
resp = self.client.post('/collector',
data=to_json(collector),
content_type='application/json')
assert_that(resp.status_code, equal_to(403))
def test_post_from_unauthorised_client_fails(self):
collector = {
"slug": "some-collector",
"type_id": self.collector_type.id,
"data_source": self.data_source.id,
"data_set": {
"data_type": self.data_set.data_type.name,
"data_group": self.data_set.data_group.name
}
}
resp = self.client.post(
'/collector',
data=to_json(collector),
content_type='application/json')
assert_that(resp.status_code, equal_to(403))
def transform(request, name):
try:
data_set = DataSet.objects.get(name=name)
except DataSet.DoesNotExist:
message = "No Data Set named '{}' exists".format(name)
return create_http_error(404, message, request, logger=logger)
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 test_put(self):
data_source = DataSourceFactory()
data_source_update = {
"name": data_source.name,
"slug": "new_slug",
"provider_id": data_source.provider.id
}
response = self.client.put(
'/data-source/{}'.format(data_source.slug),
data=to_json(data_source_update),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(200))
resp_json = json.loads(response.content)
assert_that(resp_json['slug'], equal_to("new_slug"))
def test_put(self):
data_source = DataSourceFactory()
data_source_update = {
"name": data_source.name,
"slug": "new_slug",
"provider_id": data_source.provider.id
}
response = self.client.put(
'/data-source/{}'.format(data_source.slug),
data=to_json(data_source_update),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(200))
resp_json = json.loads(response.content)
assert_that(resp_json['slug'], equal_to("new_slug"))
def test_post_with_non_existent_provider_fails(self):
provider = uuid.UUID('01234a12-1234-1234-5b6c-0de12e3a4f15')
data_source = {
'name': 'some-data-source',
'slug': 'some-data-source',
'provider_id': provider
}
response = self.client.post(
'/data-source',
data=to_json(data_source),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(400))
resp_json = json.loads(response.content)
assert_that(resp_json['message'], equal_to(
"No provider with id '{}' found".format(provider)))
def test_put(self):
collector_type = CollectorTypeFactory()
collector_type_update = {
"name": collector_type.name,
"slug": collector_type.slug,
"entry_point": "new.entry.point",
"provider_id": collector_type.provider.id
}
response = self.client.put(
'/collector-type/{}'.format(collector_type.slug),
data=to_json(collector_type_update),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(200))
resp_json = json.loads(response.content)
assert_that(resp_json['entry_point'], equal_to("new.entry.point"))
def test_post_with_non_existent_provider_fails(self):
provider = uuid.UUID('01234a12-1234-1234-5b6c-0de12e3a4f15')
data_source = {
'name': 'some-data-source',
'slug': 'some-data-source',
'provider_id': provider
}
response = self.client.post(
'/data-source',
data=to_json(data_source),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(400))
resp_json = json.loads(response.content)
assert_that(
resp_json['message'],
equal_to("No provider with id '{}' found".format(provider)))
def single_dashboard_for_spotlight(request, dashboard_slug):
dashboard = fetch_dashboard(dashboard_slug)
if not dashboard:
return error_response(request, dashboard_slug)
dashboard_json = dashboard.spotlightify(dashboard_slug)
if not dashboard_json:
return error_response(request, dashboard_slug)
json_str = to_json(dashboard_json)
response = HttpResponse(json_str, content_type='application/json')
response['Access-Control-Allow-Origin'] = '*'
if dashboard.published:
response['Cache-Control'] = 'max-age=300'
else:
response['Cache-Control'] = 'no-cache'
return response
def test_put(self):
collector_type = CollectorTypeFactory()
collector_type_update = {
"name": collector_type.name,
"slug": collector_type.slug,
"entry_point": "new.entry.point",
"provider_id": collector_type.provider.id
}
response = self.client.put(
'/collector-type/{}'.format(collector_type.slug),
data=to_json(collector_type_update),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(200))
resp_json = json.loads(response.content)
assert_that(resp_json['entry_point'], equal_to("new.entry.point"))
def test_post_with_non_existent_provider_fails(self):
provider = uuid.UUID('01234a12-1234-1234-5b6c-0de12e3a4f15')
collector_type = {
"slug": "some-collector-type",
"name": "some-collector-type",
"entry_point": "some.collector.type",
"provider_id": provider
}
response = self.client.post(
'/collector-type',
data=to_json(collector_type),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(400))
resp_json = json.loads(response.content)
assert_that(resp_json['message'], equal_to(
"No provider with id '{}' found".format(provider)))
def list_dashboards(user, request):
parsed_dashboards = []
for item in Dashboard.objects.all().order_by('title'):
parsed_dashboards.append({
'id':
item.id,
'title':
item.title,
'url':
'{0}{1}'.format(
settings.APP_ROOT,
reverse('dashboard', kwargs={'identifier': item.slug})),
'public-url':
'{0}/performance/{1}'.format(settings.GOVUK_ROOT, item.slug),
'published':
item.published
})
return HttpResponse(to_json({'dashboards': parsed_dashboards}))
def test_post_with_non_existent_provider_fails(self):
provider = uuid.UUID('01234a12-1234-1234-5b6c-0de12e3a4f15')
collector_type = {
"slug": "some-collector-type",
"name": "some-collector-type",
"entry_point": "some.collector.type",
"provider_id": provider
}
response = self.client.post(
'/collector-type',
data=to_json(collector_type),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(400))
resp_json = json.loads(response.content)
assert_that(
resp_json['message'],
equal_to("No provider with id '{}' found".format(provider)))
def test_create_dashboard_fails_with_invalid_module(self):
module_type = ModuleTypeFactory()
module = {
'slug': 'bad slug',
'title': 'bad slug',
'type_id': module_type.id,
'description': '',
'info': [],
'options': {},
'order': 1,
}
data = self._get_dashboard_payload()
data['modules'] = [module]
resp = self.client.post(
'/dashboard', to_json(data),
content_type="application/json",
HTTP_AUTHORIZATION='Bearer correct-token')
assert_that(resp.status_code, equal_to(400))
def transform(request, name):
try:
data_set = DataSet.objects.get(name=name)
except DataSet.DoesNotExist:
message = "No Data Set named '{}' exists".format(name)
return create_http_error(404, message, request, logger=logger)
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 test_post_with_non_existent_collector_type_fails(self):
collector_type = uuid.UUID('01234a12-1234-1234-5b6c-0de12e3a4f15')
collector = {
"slug": "some-collector",
"type_id": collector_type,
"data_source_id": self.data_source.id,
"data_set": {
"data_type": self.data_set.data_type.name,
"data_group": self.data_set.data_group.name
}
}
response = self.client.post(
'/collector',
data=to_json(collector),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(400))
resp_json = json.loads(response.content)
assert_that(resp_json['message'], equal_to(
"No collector type with id '{}' found".format(collector_type)))
def test_post(self):
data_source = {
"name": "some-data-source",
"slug": "some-data-source",
"provider_id": self.provider.id
}
resp = self.client.post(
'/data-source',
data=to_json(data_source),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(resp.status_code, equal_to(200))
resp_json = json.loads(resp.content)
assert_that(resp_json, has_key('id'))
assert_that(resp_json['name'], equal_to('some-data-source'))
assert_that(resp_json['slug'], equal_to('some-data-source'))
assert_that(resp_json['provider']['name'], equal_to(
self.provider.name))
def test_post(self):
data_source = {
"name": "some-data-source",
"slug": "some-data-source",
"provider_id": self.provider.id
}
resp = self.client.post(
'/data-source',
data=to_json(data_source),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(resp.status_code, equal_to(200))
resp_json = json.loads(resp.content)
assert_that(resp_json, has_key('id'))
assert_that(resp_json['name'], equal_to('some-data-source'))
assert_that(resp_json['slug'], equal_to('some-data-source'))
assert_that(resp_json['provider']['name'],
equal_to(self.provider.name))
def test_post_with_non_existent_data_set_fails(self):
data_set = {
"data_type": "some-data-type",
"data_group": "some-data-group"
}
collector = {
"slug": "some-collector",
"type_id": self.collector_type.id,
"data_source_id": self.data_source.id,
"data_set": data_set
}
response = self.client.post(
'/collector',
data=to_json(collector),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(400))
resp_json = json.loads(response.content)
assert_that(resp_json['message'], equal_to(
"No data set with data group '{}' and data type '{}' found"
"".format(data_set['data_group'], data_set['data_type'])))
def test_post_with_non_existent_data_source_fails(self):
data_source = uuid.UUID('01234a12-1234-1234-5b6c-0de12e3a4f15')
collector = {
"slug": "some-collector",
"type_id": self.collector_type.id,
"data_source_id": data_source,
"data_set": {
"data_type": self.data_set.data_type.name,
"data_group": self.data_set.data_group.name
}
}
response = self.client.post(
'/collector',
data=to_json(collector),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
assert_that(response.status_code, equal_to(400))
resp_json = json.loads(response.content)
assert_that(
resp_json['message'],
equal_to("No data source with id '{}' found".format(data_source)))
def test_post(self):
collector = {
"slug": "some-collector",
"type_id": self.collector_type.id,
"data_source_id": self.data_source.id,
"data_set": {
"data_type": self.data_set.data_type.name,
"data_group": self.data_set.data_group.name
}
}
resp = self.client.post(
'/collector',
data=to_json(collector),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
content_type='application/json')
expected_collector_name = "{} {} {}".format(
self.collector_type.name,
self.data_set.data_group.name,
self.data_set.data_type.name
)
assert_that(resp.status_code, equal_to(200))
resp_json = json.loads(resp.content)
assert_that(resp_json, has_key('id'))
assert_that(resp_json['slug'], equal_to("some-collector"))
assert_that(resp_json['name'], equal_to(expected_collector_name))
assert_that(resp_json['data_source']['name'],
equal_to(self.data_source.name))
assert_that(resp_json['data_set']['data_type'],
equal_to(self.data_set.data_type.name))
assert_that(resp_json['data_set']['data_group'],
equal_to(self.data_set.data_group.name))
def dashboard_list_for_spotlight():
dashboard_json = Dashboard.list_for_spotlight()
json_str = to_json(dashboard_json)
response = HttpResponse(json_str, content_type='application/json')
response['Cache-Control'] = 'max-age=300'
return response
def health_check(request):
num_data_sets = DataSet.objects.count()
json_response = to_json(
{'message': 'Got {} data sets.'.format(num_data_sets)})
return HttpResponse(json_response, content_type='application/json')
def get_dashboard_by_uuid(user, request, dashboard_id=None):
dashboard = get_object_or_404(Dashboard, id=dashboard_id)
return HttpResponse(to_json(dashboard.serialize()),
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')
def dashboard_list_for_spotlight():
dashboard_json = Dashboard.list_for_spotlight()
json_str = to_json(dashboard_json)
response = HttpResponse(json_str, content_type='application/json')
response['Cache-Control'] = 'max-age=300'
return response
def health_check(request):
num_data_sets = DataSet.objects.count()
json_response = to_json(
{'message': 'Got {} data sets.'.format(num_data_sets)})
return HttpResponse(json_response, content_type='application/json')
