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_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 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_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_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')