def test_place_partial_update(self):
request = RequestFactory().get('')
request.get_dataset = lambda: self.dataset
view = PlaceInstanceView()
view.request = request
serializer = PlaceSerializer(
self.place,
context={
'view': view,
'request': request,
'include_private': True
},
data={
'private-attr': 4,
'new-attr': 5,
'geometry': 'POINT(4 5)'
},
partial=True,
)
self.assert_(serializer.is_valid())
serializer.save()
self.assertEqual(json.loads(self.place.data), {
'public-attr': 1,
'private-attr': 4,
'new-attr': 5
})
self.assertEqual(self.place.geometry.wkt,
GEOSGeometry('POINT(4 5)').wkt)
def test_visible_has_truthy_boolean_values(self):
# You should be able to use case-insensitive "on", "yes" and "true" for
# the visible value (primarily for backwards compatibility).
request = RequestFactory().get('')
request.get_dataset = lambda: self.dataset
view = PlaceInstanceView()
view.request = request
self.place.visible = False
self.place.save()
self.place.refresh_from_db()
self.assert_(not self.place.visible)
serializer = PlaceSerializer(
self.place,
context={
'view': view,
'request': request
},
data={'visible': 'On'},
partial=True,
)
self.assert_(serializer.is_valid())
serializer.save()
self.place.refresh_from_db()
self.assert_(self.place.visible)
def generate_bulk_content(dataset, submission_set_name, **flags):
renderer_classes = {
'csv': CSVRenderer,
'json': GeoJSONRenderer if submission_set_name == 'places' else JSONRenderer
}
if submission_set_name == 'places':
submissions = dataset.places.all()
serializer = SimplePlaceSerializer(submissions, many=True)
else:
submissions = dataset.submissions.filter(set_name=submission_set_name)
serializer = SimpleSubmissionSerializer(submissions, many=True)
# Construct a request for the serializer context
r_data = {}
for flag_attr, flag_val in flags.iteritems():
if flag_val: r_data[flag_attr] = 'true'
r = RequestFactory().get('', data=r_data)
r.get_dataset = lambda: dataset
# Render the data in each format
serializer.context['request'] = r
data = serializer.data
content = {}
for format, renderer_class in renderer_classes.items():
renderer = renderer_class()
content[format] = renderer.render(data)
return content
def generate_bulk_content(dataset, submission_set_name, format, **flags):
renderer_classes = {
'csv': CSVRenderer,
'json': JSONRenderer,
'geojson': GeoJSONRenderer
}
if submission_set_name == 'places':
submissions = dataset.places.all()
serializer = PlaceSerializer(submissions)
if format == 'json': format = 'geojson'
else:
submissions = dataset.submissions.filter(parent__name=submission_set_name)
serializer = SubmissionSerializer(submissions)
# Construct a request for the serializer context
r_data = {}
for flag_attr, flag_val in flags.iteritems():
if flag_val: r_data[flag_attr] = 'true'
r = RequestFactory().get('', data=r_data)
r.get_dataset = lambda: dataset
serializer.context['request'] = r
data = serializer.data
renderer = renderer_classes.get(format)()
content = renderer.render(data)
return content
def test_place_has_right_number_of_submissions(self):
request = RequestFactory().get('')
request.get_dataset = lambda: self.dataset
serializer = PlaceSerializer(self.place)
serializer.context = {'request': request}
self.assertEqual(serializer.data['submission_sets']['comments']['length'], 2)
def test_place_hides_private_data_by_default(self):
request = RequestFactory().get('')
request.get_dataset = lambda: self.dataset
serializer = PlaceSerializer(self.place, context={'request': request})
self.assertIn('public-attr', serializer.data)
self.assertNotIn('private-attr', serializer.data)
def test_place_has_right_number_of_submissions(self):
request = RequestFactory().get('')
request.get_dataset = lambda: self.dataset
serializer = PlaceSerializer(self.place, context={'request': request})
self.assertEqual(
serializer.data['submission_sets']['comments']['length'], 2)
def test_can_serlialize_a_null_instance(self):
request = RequestFactory().get('')
request.get_dataset = lambda: self.dataset
serializer = PlaceSerializer(None, context={'request': request})
data = serializer.data
self.assertIsInstance(data, dict)
def test_place_has_right_number_of_submissions(self):
request = RequestFactory().get("")
request.get_dataset = lambda: self.dataset
serializer = PlaceSerializer(self.place)
serializer.context = {"request": request}
self.assertEqual(serializer.data["submission_sets"]["comments"]["length"], 2)
def test_can_serlialize_a_null_instance(self):
request = RequestFactory().get('')
request.get_dataset = lambda: self.dataset
serializer = PlaceSerializer(None)
serializer.context = {'request': request}
data = serializer.data
self.assertIsInstance(data, dict)
def test_submission_includes_private_data_when_specified(self):
request = RequestFactory().get('')
request.get_dataset = lambda: self.dataset
serializer = SubmissionSerializer(self.submission,
context={
'request': request,
'include_private': True
})
self.assertIn('public-attr', serializer.data)
self.assertIn('private-attr', serializer.data)
def load_dataset_archive(dataset_id, archive_url):
dataset = DataSet.objects.get(id=dataset_id)
archive_response = requests.get(archive_url)
if archive_response.status_code == 200:
data = archive_response.json()
# Preload users
users_map = preload_users(data)
with transaction.atomic():
# Construct the dataset from metadata
metadata = data.get('metadata')
if metadata:
metadata.pop('id', None)
metadata.pop('owner', None)
serializer = SimpleDataSetSerializer(dataset,
data=data.get('metadata'))
assert serializer.is_valid, list_errors(serializer.errors)
serializer.save()
# Construct each place and submission individually
for place_data in data.get('features'):
place_data.pop('type', None)
place_data.update(place_data.pop('properties', {}))
place_data.pop('id', None)
place_data.pop('dataset', None)
place_data.pop('created_datetime', None)
place_data.pop('updated_datetime', None)
submission_sets_data = place_data.pop('submission_sets', {})
submitter_data = place_data.pop('submitter', None)
serializer = SimplePlaceSerializer(data=place_data)
assert serializer.is_valid(), list_errors(serializer.errors)
# Construct a request for the serializer context
r = RequestFactory().get('', data={})
r.get_dataset = lambda: dataset
# Render the data in each format
serializer.context['request'] = r
serializer.save(dataset=dataset,
submitter=get_or_create_user(
submitter_data, users_map),
silent=True,
reindex=False)
for set_name, submissions_data in submission_sets_data.iteritems(
):
for submission_data in submissions_data:
submission_data.pop('id', None)
submission_data.pop('place', None)
submission_data.pop('dataset', None)
submission_data.pop('attachments', None)
submission_data.pop('created_datetime', None)
submission_data.pop('updated_datetime', None)
submitter_data = submission_data.pop('submitter', None)
serializer = SimpleSubmissionSerializer(
data=submission_data)
assert serializer.is_valid(), list_errors(
serializer.errors)
submission = serializer.object
submission.set_name = set_name
submission.place = place
submission.dataset = dataset
submission.submitter = get_or_create_user(
submitter_data, users_map)
submission.save(silent=True, reindex=False)
dataset.reindex()
