def test_list_no_allowed_fields(self):
PermissionFactory.create(
object_type=self.object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"2": ["url", "type", "record"]},
)
PermissionFactory.create(
object_type=self.other_object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"2": ["url", "uuid", "record"]},
)
ObjectRecordFactory.create(object__object_type=self.object_type,
data={"name": "some"},
version=1)
ObjectRecordFactory.create(
object__object_type=self.other_object_type,
data={"name": "other"},
version=1,
)
url = reverse("object-list")
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), [{}, {}])
self.assertIn("x-unauthorized-fields", response._headers)
def test_list_incorrect_auth_fields(self):
PermissionFactory.create(
object_type=self.object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"1": ["url", "some", "record"]},
)
PermissionFactory.create(
object_type=self.other_object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"1": ["url", "uuid", "record"]},
)
ObjectRecordFactory.create(object__object_type=self.object_type,
data={"name": "some"},
version=1)
ObjectRecordFactory.create(
object__object_type=self.other_object_type,
data={"name": "other"},
version=1,
)
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.json(),
[
"Fields in the configured authorization are absent in the data: 'some'"
],
)
def test_list_query_fields_not_allowed(self):
PermissionFactory.create(
object_type=self.object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"1": ["url", "type", "record"]},
)
PermissionFactory.create(
object_type=self.other_object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"1": ["url", "uuid", "record"]},
)
ObjectRecordFactory.create(object__object_type=self.object_type,
data={"name": "some"})
ObjectRecordFactory.create(object__object_type=self.other_object_type,
data={"name": "other"})
response = self.client.get(self.url, {"fields": "uuid"})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.json(),
[
"'fields' query parameter has invalid or unauthorized values: 'uuid'"
],
)
def test_retrieve_query_fields_not_allowed(self):
PermissionFactory.create(
object_type=self.object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"1": ["url", "type", "record__data__name"]},
)
object = ObjectFactory.create(object_type=self.object_type)
ObjectRecordFactory.create(object=object,
data={
"name": "some",
"desc": "some desc"
},
version=1)
url = reverse("object-detail", args=[object.uuid])
response = self.client.get(url, {"fields": "url,type,record__data"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.json(),
{
"url": f"http://testserver{url}",
"record": {
"data": {
"name": "some"
}
},
"type": self.object_type.url,
},
)
self.assertEqual(response._headers["x-unauthorized-fields"][1],
"record__data__desc")
def test_filter_with_nesting(self):
record = ObjectRecordFactory.create(
data={"person": {
"name": "Something important"
}},
object__object_type=self.object_type,
)
ObjectRecordFactory.create(
data={"person": {
"name": "Nothing important"
}},
object__object_type=self.object_type,
)
ObjectRecordFactory.create(data={},
object__object_type=self.object_type)
response = self.client.get(self.url, {"data_icontains": "some"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()["results"]
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f"http://testserver{reverse('object-detail', args=[record.object.uuid])}",
)
def test_several_fields(self):
record1 = ObjectRecordFactory.create(
object__object_type=self.object_type,
start_at=date(2020, 1, 1),
index=2,
)
record2 = ObjectRecordFactory.create(
object__object_type=self.object_type,
start_at=date(2020, 1, 1),
index=1)
record3 = ObjectRecordFactory.create(
object__object_type=self.object_type,
start_at=date(2020, 1, 3),
index=1)
response = self.client.get(
self.url, {"ordering": "-record__startAt,record__index"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()["results"]
self.assertEqual(len(data), 3)
self.assertEqual(data[0]["uuid"], str(record3.object.uuid))
self.assertEqual(data[1]["uuid"], str(record2.object.uuid))
self.assertEqual(data[2]["uuid"], str(record1.object.uuid))
def test_filter_objecttype(self):
record = ObjectRecordFactory.create(
geometry=Point(4.905289, 52.369918), object__object_type=self.object_type
)
ObjectRecordFactory.create(
geometry=Point(4.905289, 52.369918),
object__object_type=self.another_object_type,
)
response = self.client.post(
self.url,
{
"geometry": {
"within": {
"type": "Polygon",
"coordinates": [POLYGON_AMSTERDAM_CENTRUM],
}
},
"type": self.object_type.url,
},
**GEO_WRITE_KWARGS,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f'http://testserver{reverse("object-detail", args=[record.object.uuid])}',
)
def test_retrieve_with_selected_fields(self):
object = ObjectFactory.create(object_type=self.object_type)
ObjectRecordFactory.create(
object=object,
start_at=date.today(),
geometry="POINT (4.910649523925713 52.37240093589432)",
)
url = reverse("object-detail", args=[object.uuid])
response = self.client.get(url,
{"fields": "url,type,record__geometry"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(
data,
{
"url":
f'http://testserver{reverse("object-detail", args=[object.uuid])}',
"type": object.object_type.url,
"record": {
"geometry": {
"type": "Point",
"coordinates": [4.910649523925713, 52.37240093589432],
},
},
},
)
def test_filter_registration_date_list(self):
# object 1 - show
object1 = ObjectFactory.create(object_type=self.object_type)
record11 = ObjectRecordFactory.create(
object=object1, registration_at="2020-01-01"
)
record12 = ObjectRecordFactory.create(
object=object1, registration_at="2021-01-01"
)
# object 2 - don't show
record21 = ObjectRecordFactory.create(
object__object_type=self.object_type, registration_at="2021-01-01"
)
url = reverse_lazy("object-list")
response = self.client.get(url, {"registrationDate": "2020-07-01"})
data = response.json()
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f"http://testserver{reverse('object-detail', args=[object1.uuid])}",
)
self.assertEqual(data[0]["record"]["index"], record11.index)
def setUpTestData(cls):
super().setUpTestData()
cls.object_type = ObjectTypeFactory(service__api_root=OBJECT_TYPES_API)
cls.object = ObjectFactory.create(object_type=cls.object_type)
cls.record_1 = ObjectRecordFactory.create(
object=cls.object,
data={
"geslachtsnaam": "Poepenstaart",
"voorletters": "JP",
"geboortedatum": "1977-08-07",
"burgerlijkestaat": "ongehuwd",
},
start_at=date(1977, 8, 7),
end_at=date(2001, 9, 3),
registration_at=date(1977, 8, 15),
)
cls.record_10 = ObjectRecordFactory.create(
object=cls.object,
data={
"geslachtsnaam": "Berg",
"voorletters": "JP",
"geboortedatum": "1977-08-07",
"burgerlijkestaat": "ongehuwd",
},
start_at=date(2001, 9, 3),
end_at=date(2001, 9, 3),
registration_at=date(2001, 9, 10),
)
cls.record_40 = ObjectRecordFactory.create(
object=cls.object,
data={
"geslachtsnaam": "Bergh",
"voorvoegsel": "van den",
"voorletters": "JP",
"geboortedatum": "1977-08-07",
"burgerlijkestaat": "ongehuwd",
},
start_at=date(2001, 9, 3),
end_at=date(2005, 4, 23),
registration_at=date(2001, 11, 2),
)
cls.record_50 = ObjectRecordFactory.create(
object=cls.object,
data={
"geslachtsnaam": "Bergh",
"voorvoegsel": "van den",
"voorletters": "JP",
"geboortedatum": "1977-08-07",
"burgerlijkestaat": "gehuwd",
},
start_at=date(2005, 4, 23),
registration_at=date(2005, 4, 25),
)
PermissionFactory.create(
object_type=cls.object_type,
mode=PermissionModes.read_and_write,
token_auth=cls.token_auth,
)
def test_filter_comma_separated(self):
record = ObjectRecordFactory.create(
data={"dimensions": {"diameter": 4}, "name": "demo"},
object__object_type=self.object_type,
)
ObjectRecordFactory.create(
data={"dimensions": {"diameter": 5}, "name": "demo"},
object__object_type=self.object_type,
)
ObjectRecordFactory.create(
data={"dimensions": {"diameter": 4}, "name": "other"},
object__object_type=self.object_type,
)
response = self.client.get(
self.url, {"data_attrs": "dimensions__diameter__exact__4,name__exact__demo"}
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f"http://testserver{reverse('object-detail', args=[record.object.uuid])}",
)
def test_search_objects_limited_to_object_permission(self):
PermissionFactory.create(
object_type=self.object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
)
record = ObjectRecordFactory.create(
geometry=Point(4.905289, 52.369918), object__object_type=self.object_type
)
ObjectRecordFactory.create(geometry=Point(4.905289, 52.369918))
url = reverse("object-search")
response = self.client.post(
url,
{
"geometry": {
"within": {
"type": "Polygon",
"coordinates": [POLYGON_AMSTERDAM_CENTRUM],
}
},
"type": self.object_type.url,
},
**GEO_WRITE_KWARGS,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f"http://testserver{reverse('object-detail', args=[record.object.uuid])}",
)
def test_filter_within(self):
# in district
record = ObjectRecordFactory.create(
object__object_type=self.object_type, geometry=Point(4.905289, 52.369918)
)
# outside of district
ObjectRecordFactory.create(
object__object_type=self.object_type, geometry=Point(4.905650, 52.357621)
)
# no geo set
ObjectRecordFactory.create(object__object_type=self.object_type)
response = self.client.post(
self.url,
{
"geometry": {
"within": {
"type": "Polygon",
"coordinates": [POLYGON_AMSTERDAM_CENTRUM],
}
}
},
**GEO_WRITE_KWARGS,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f'http://testserver{reverse("object-detail", args=[record.object.uuid])}',
)
def test_delete_without_geo_headers(self):
object = ObjectFactory.create(object_type=self.object_type)
ObjectRecordFactory.create(object=object)
url = reverse("object-detail", args=[object.uuid])
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_history_no_object_permissions(self):
object = ObjectFactory.create()
ObjectRecordFactory.create(object=object)
url = reverse("object-history", args=[object.uuid])
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_get_with_geo_headers(self):
object = ObjectFactory.create(object_type=self.object_type)
ObjectRecordFactory.create(object=object)
url = reverse("object-detail", args=[object.uuid])
response = self.client.get(url, **GEO_READ_KWARGS)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertResponseHasGeoHeaders(response)
def test_list_actual_objects(self, m):
object_record1 = ObjectRecordFactory.create(
object__object_type=self.object_type,
start_at=date.today(),
)
object_record2 = ObjectRecordFactory.create(
object__object_type=self.object_type,
start_at=date.today() - timedelta(days=10),
end_at=date.today() - timedelta(days=1),
)
url = reverse("object-list")
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(
data,
{
"count":
1,
"next":
None,
"previous":
None,
"results": [{
"url":
f'http://testserver{reverse("object-detail", args=[object_record1.object.uuid])}',
"uuid": str(object_record1.object.uuid),
"type": object_record1.object.object_type.url,
"record": {
"index":
object_record1.index,
"typeVersion":
object_record1.version,
"data":
object_record1.data,
"geometry":
json.loads(object_record1.geometry.json),
"startAt":
object_record1.start_at.isoformat(),
"endAt":
object_record1.end_at,
"registrationAt":
object_record1.registration_at.isoformat(),
"correctionFor":
None,
"correctedBy":
None,
},
}],
},
)
def test_send_notif_partial_update_object(self, mocker, mock_client):
"""
Check if notifications will be send when Object is created
"""
client = mock_client.return_value
mock_service_oas_get(mocker, OBJECT_TYPES_API, "objecttypes")
mocker.get(
f"{self.object_type.url}/versions/1",
json=mock_objecttype_version(self.object_type.url),
)
mocker.get(self.object_type.url,
json=mock_objecttype(self.object_type.url))
obj = ObjectFactory.create(object_type=self.object_type)
ObjectRecordFactory.create(object=obj)
url = reverse("object-detail", args=[obj.uuid])
data = {
"type": self.object_type.url,
"record": {
"typeVersion": 1,
"data": {
"plantDate": "2020-04-12",
"diameter": 30
},
"geometry": {
"type": "Point",
"coordinates": [4.910649523925713, 52.37240093589432],
},
"startAt": "2020-01-01",
},
}
with capture_on_commit_callbacks(execute=True):
response = self.client.patch(url, data, **GEO_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
data = response.json()
client.create.assert_called_once_with(
"notificaties",
{
"kanaal": "objecten",
"hoofdObject": data["url"],
"resource": "object",
"resourceUrl": data["url"],
"actie": "partial_update",
"aanmaakdatum": "2018-09-07T02:00:00+02:00",
"kenmerken": {
"objectType": self.object_type.url,
},
},
)
def test_3a_3_records_found(self):
"""
Test 3a: If records 1, 40 and 50 exists, material history and formal history
on 01-01-2020 should say: Record 50
"""
record_1 = ObjectRecordFactory.create(
object=self.object,
data={
"geslachtsnaam": "Poepenstaart",
"voorletters": "JP",
"geboortedatum": "1977-08-07",
"burgerlijkestaat": "ongehuwd",
},
start_at=date(1977, 8, 7),
end_at=date(2001, 9, 3),
registration_at=date(1977, 8, 7),
)
record_40 = ObjectRecordFactory.create(
object=self.object,
data={
"geslachtsnaam": "Bergh",
"voorvoegsel": "van den",
"voorletters": "JP",
"geboortedatum": "1977-08-07",
"burgerlijkestaat": "ongehuwd",
},
start_at=date(2001, 9, 3),
end_at=date(2005, 4, 23),
registration_at=date(2001, 9, 3),
)
record_50 = ObjectRecordFactory.create(
object=self.object,
data={
"geslachtsnaam": "Bergh",
"voorvoegsel": "van den",
"voorletters": "JP",
"geboortedatum": "1977-08-07",
"burgerlijkestaat": "gehuwd",
},
start_at=date(2005, 4, 23),
registration_at=date(2005, 4, 23),
)
material_response = self.client.get(self.url, {"date": "2020-01-01"})
formal_response = self.client.get(self.url,
{"registrationDate": "2020-01-01"})
for response in [formal_response, material_response]:
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()["url"],
f"http://testserver{self.url}")
self.assertEqual(response.json()["record"]["index"],
record_50.index)
def test_list_with_query_fields(self):
other_object_type = ObjectTypeFactory()
PermissionFactory.create(
object_type=self.object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"1": ["url", "type", "record"]},
)
PermissionFactory.create(
object_type=other_object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
use_fields=True,
fields={"1": ["url", "uuid", "record"]},
)
record1 = ObjectRecordFactory.create(
object__object_type=self.object_type,
data={"name": "some"},
version=1)
record2 = ObjectRecordFactory.create(
object__object_type=other_object_type,
data={"name": "other"},
version=1)
response = self.client.get(self.url, {"fields": "url,record__data"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.json(),
[
{
"url":
f"http://testserver{reverse('object-detail', args=[record2.object.uuid])}",
"record": {
"data": {
"name": "other"
},
},
},
{
"url":
f"http://testserver{reverse('object-detail', args=[record1.object.uuid])}",
"record": {
"data": {
"name": "some"
},
},
},
],
)
self.assertNotIn("x-unauthorized-fields", response._headers)
def test_history_with_read_only_permissions(self):
PermissionFactory.create(
object_type=self.object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
)
object = ObjectFactory.create(object_type=self.object_type)
ObjectRecordFactory.create(object=object)
url = reverse("object-history", args=[object.uuid])
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_destroy_with_read_only_perm(self):
PermissionFactory.create(
object_type=self.object_type,
mode=PermissionModes.read_only,
token_auth=self.token_auth,
)
object = ObjectFactory.create(object_type=self.object_type)
ObjectRecordFactory.create(object=object)
url = reverse("object-detail", args=[object.uuid])
response = self.client.delete(url, **GEO_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_1a_1_record_found(self):
"""
Test 1a: If only record 1 (record with volgnummer=1) exists, material history
and formal history on 01-01-2020 should say: Record 1
"""
record_1 = ObjectRecordFactory.create(
object=self.object,
data={
"geslachtsnaam": "Poepenstaart",
"voorletters": "JP",
"geboortedatum": "1977-08-07",
"burgerlijkestaat": "ongehuwd",
},
start_at=date(1977, 8, 7),
registration_at=date(1977, 8, 7),
)
material_response = self.client.get(self.url, {"date": "2020-01-01"})
formal_response = self.client.get(self.url,
{"registrationDate": "2020-01-01"})
for response in [formal_response, material_response]:
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()["url"],
f"http://testserver{self.url}")
self.assertEqual(response.json()["record"]["index"],
record_1.index)
def test_create_object_correction_invalid(self, m):
mock_service_oas_get(m, OBJECT_TYPES_API, "objecttypes")
m.get(
f"{self.object_type.url}/versions/1",
json=mock_objecttype_version(self.object_type.url),
)
record = ObjectRecordFactory.create()
url = reverse("object-list")
data = {
"type": self.object_type.url,
"record": {
"typeVersion": 1,
"data": {
"plantDate": "2020-04-12",
"diameter": 30
},
"startAt": "2020-01-01",
"correctionFor": record.index,
},
}
response = self.client.post(url, data, **GEO_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
Object.objects.exclude(id=record.object.id).count(), 0)
data = response.json()
self.assertEqual(
data["record"]["correctionFor"],
[f"Object with index={record.index} does not exist."],
)
def test_update_object_type_invalid(self, m):
old_object_type = ObjectTypeFactory(service=self.object_type.service)
PermissionFactory.create(
object_type=old_object_type,
mode=PermissionModes.read_and_write,
token_auth=self.token_auth,
)
mock_service_oas_get(m, OBJECT_TYPES_API, "objecttypes")
m.get(self.object_type.url, json=mock_objecttype(self.object_type.url))
initial_record = ObjectRecordFactory.create(
object__object_type=old_object_type,
data={
"plantDate": "2020-04-12",
"diameter": 30
},
version=1,
)
object = initial_record.object
url = reverse("object-detail", args=[object.uuid])
data = {
"type": self.object_type.url,
}
response = self.client.patch(url, data, **GEO_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
data = response.json()
self.assertEqual(
data["type"],
["This field can't be changed"],
)
def test_filter_date_detail(self):
object = ObjectFactory.create(object_type=self.object_type)
record1 = ObjectRecordFactory.create(
object=object, start_at="2020-01-01", end_at="2020-12-31"
)
record2 = ObjectRecordFactory.create(object=object, start_at="2021-01-01")
url = reverse_lazy("object-detail", args=[object.uuid])
response = self.client.get(url, {"date": "2020-07-01"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(data["record"]["index"], record1.index)
def test_filter_lte_date(self):
record = ObjectRecordFactory.create(
data={"date": "2000-11-01"}, object__object_type=self.object_type)
response = self.client.get(self.url,
{"data_attrs": "date__lte__2000-12-01"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()["results"]
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f"http://testserver{reverse('object-detail', args=[record.object.uuid])}",
)
response = self.client.get(self.url,
{"data_attrs": "date__lte__2000-10-01"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()["results"]
self.assertEqual(len(data), 0)
response = self.client.get(self.url,
{"data_attrs": "date__lte__2000-11-01"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()["results"]
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f"http://testserver{reverse('object-detail', args=[record.object.uuid])}",
)
def test_filter_object_type(self):
object = ObjectFactory.create(object_type=self.object_type)
ObjectRecordFactory.create(object=object)
ObjectFactory.create(object_type=self.another_object_type)
response = self.client.get(self.url, {"type": self.object_type.url})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(len(data), 1)
self.assertEqual(
data[0]["url"],
f"http://testserver{reverse('object-detail', args=[object.uuid])}",
)
def test_filter_exclude_old_records(self):
record_old = ObjectRecordFactory.create(
data={"diameter": 45},
object__object_type=self.object_type,
start_at=date.today() - timedelta(days=10),
end_at=date.today() - timedelta(days=1),
)
record_new = ObjectRecordFactory.create(
data={"diameter": 50}, object=record_old.object, start_at=record_old.end_at
)
response = self.client.get(self.url, {"data_attrs": "diameter__exact__45"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(len(data), 0)
def test_history_object(self, m):
record1 = ObjectRecordFactory.create(
object__object_type=self.object_type,
start_at=date(2020, 1, 1),
geometry="POINT (4.910649523925713 52.37240093589432)",
)
object = record1.object
record2 = ObjectRecordFactory.create(object=object,
start_at=date.today(),
correct=record1)
url = reverse("object-history", args=[object.uuid])
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(
data,
[
{
"index": 1,
"typeVersion": record1.version,
"data": record1.data,
"geometry": json.loads(record1.geometry.json),
"startAt": record1.start_at.isoformat(),
"endAt": record2.start_at.isoformat(),
"registrationAt": record1.registration_at.isoformat(),
"correctionFor": None,
"correctedBy": 2,
},
{
"index": 2,
"typeVersion": record2.version,
"data": record2.data,
"geometry": json.loads(record2.geometry.json),
"startAt": record2.start_at.isoformat(),
"endAt": None,
"registrationAt": date.today().isoformat(),
"correctionFor": 1,
"correctedBy": None,
},
],
)
