def setUp(self):
super(self.__class__, self).setUp()
conn = DBConnection()
conn.alias = 'pepito'
conn.engine = settings.DATABASES['default']['ENGINE']
conn.name = settings.DATABASES['default']['NAME']
conn.user = settings.DATABASES['default']['USER']
conn.password = settings.DATABASES['default']['PASSWORD']
conn.host = settings.DATABASES['default']['HOST']
conn.port = settings.DATABASES['default']['PORT']
conn.save()
layer = DataBaseLayer()
layer.db_connection = conn
layer.name = 'tests_location'
layer.table = 'tests_location'
layer.pk_field = 'id'
layer.geom_field = 'geometry'
layer.save()
self.layer = layer
Location = create_dblayer_model(layer)
location = Location()
location.address = 'C/ Jaume 1, Girona'
location.geometry = 'POINT(0 1)'
location.save()
self.location = location
self.LocationModel = Location
def test_bulk_creationdate_create(self):
field = self.layer.fields.filter(name='creationdate').first()
field.widget = DataBaseLayerField.WIDGET_CHOICES.creationdate
field.readonly = True
field.save()
code = 'A101'
today = datetime.now(tz=get_current_timezone())
self.login_test_user()
data = {
'ADD': [
{
'code': code,
'address': 'C/ Jaume 100, Girona',
'geometry': 'POINT (0 10)'
}
],
'UPDATE': [],
'DELETE': []
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 200)
Location = create_dblayer_model(self.layer)
obj = Location.objects.get(code=code)
self.assertIsNotNone(obj.creationdate)
self.assertEqual(obj.creationdate, today.date())
def setUp(self):
super(self.__class__, self).setUp()
conn = DBConnection()
conn.alias = 'test_connection'
conn.engine = settings.DATABASES['default']['ENGINE']
conn.name = settings.DATABASES['default']['NAME']
conn.user = settings.DATABASES['default']['USER']
conn.password = settings.DATABASES['default']['PASSWORD']
conn.host = settings.DATABASES['default']['HOST']
conn.port = settings.DATABASES['default']['PORT']
conn.save()
layer = DataBaseLayer()
layer.db_connection = conn
layer.name = 'tests-location'
layer.table = 'tests_location'
layer.pk_field = 'code'
layer.geom_field = 'geometry'
layer.anonymous_view = True
layer.anonymous_add = True
layer.anonymous_update = True
layer.anonymous_delete = True
layer.save()
self.layer = layer
self.locations = []
Location = create_dblayer_model(layer)
self.Location = Location
for i in range(0, 12):
location = Location()
location.code = 'C%s' % str(i).zfill(3)
location.address = 'C/ Jaume %s, Girona' % i
location.geometry = 'POINT(0 %s)' % i
location.save()
self.locations.append(location)
def test_empty_imge_url(self):
Model = create_dblayer_model(self.layer)
test_model = Model()
test_model.code = 'B%s' % 1
test_model.geometry = 'POINT (%s 10)' % 1
test_model.save()
url = reverse('content-list', kwargs={'name': self.layer.name})
response = self.client.get(url)
result = response.json()
item = result['features'][0]
self.assertEqual(item['properties']['image'], None)
def test_bulk_ok(self):
data = {
'ADD': [
{
'code': 'A101',
'address': 'C/ Jaume 100, Girona',
'geometry': 'POINT (0 10)'
},
{
'code': 'A102',
'address': 'C/ Jaume 100, Girona',
'geometry': 'POINT (11 10)'
},
],
'UPDATE': [{
'code': self.locations[2].code,
'geometry': 'POINT (0 10)'
}, {
'code': self.locations[5].code,
'address': 'C/ Cor de Maria 5, Girona',
'geometry': 'POINT (11 10)'
}, {
'code': self.locations[1].code,
'address': 'C/ Cor de Maria 1, Girona'
}],
'DELETE': [self.locations[9].code, self.locations[10].code]
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 200)
Location = create_dblayer_model(self.layer)
obj = Location.objects.get(code=data['ADD'][0]['code'])
self.assertEqual(obj.geometry.wkt, data['ADD'][0]['geometry'])
self.assertEqual(obj.address, data['ADD'][0]['address'])
obj = Location.objects.get(code=data['ADD'][1]['code'])
self.assertEqual(obj.geometry.wkt, data['ADD'][1]['geometry'])
self.assertEqual(obj.address, data['ADD'][1]['address'])
obj = Location.objects.get(code=self.locations[2].code)
self.assertEqual(obj.geometry.wkt, data['UPDATE'][0]['geometry'])
obj = Location.objects.get(code=self.locations[5].code)
self.assertEqual(obj.address, data['UPDATE'][1]['address'])
self.assertEqual(obj.geometry.wkt, data['UPDATE'][1]['geometry'])
obj = Location.objects.get(code=self.locations[1].code)
self.assertEqual(obj.address, data['UPDATE'][2]['address'])
self.assertEqual(
0,
Location.objects.filter(code__in=data['DELETE']).count())
def test_bulk_undo_create(self):
"""
Undo created object due a failed update
"""
self.login_test_user()
Model = create_dblayer_model(self.layer)
self.assertEqual(Model.objects.all().count(), 0)
url = reverse('user_assets-list')
files = ['2210571.jpg', 'giscube_01.png']
assets = {}
for filename in files:
path = 'tests/files/%s' % filename
f = open(path, 'rb')
data = {'file': f}
response = self.client.post(url, data)
f.close()
assets[filename] = response.data
data = {
'ADD': [{
'code': 'C1',
'geometry': 'POINT (0 10)',
'image': assets['2210571.jpg']['file']
}],
'UPDATE': [
{
'code': 'XX',
'geometry': 'POINT (0 63)',
'image': assets['giscube_01.png']['file']
},
],
'DELETE': []
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 400)
dirs, files = Model._meta.get_field('image').storage.listdir('.')
self.assertEqual(len(files), 0)
dirs, files = Model._meta.get_field(
'image').storage.get_thumbnail_storage().listdir('.')
self.assertEqual(len(files), 0)
self.assertEqual(Model.objects.all().count(), 0)
self.assertEqual(UserAsset.objects.all().count(),
len(list(assets.keys())))
def create_model(self, readonly_fields=None):
readonly_fields = readonly_fields or ['address']
self.layer.fields.filter(name__in=readonly_fields).update(
readonly=True)
self.locations = []
Location = create_dblayer_model(self.layer)
self.Location = Location
for i in range(0, 4):
location = Location()
location.code = 'C%s' % str(i).zfill(3)
location.address = 'C/ Jaume %s, Girona' % i
location.geometry = 'POINT(0 %s)' % i
location.save()
self.locations.append(location)
def add_test_files(self, files):
Model = create_dblayer_model(self.layer)
test_files = []
i = 0
for filename in files:
test_model = Model()
test_model.code = 'B%s' % i
test_model.name = 'Abies alba'
path = 'tests/files/%s' % filename
f = open(path, 'rb')
test_model.image.save(name=filename, content=File(f))
test_model.save()
f.close()
test_files.append(test_model)
i += 1
return test_files
def to_representation(self, obj):
data = super().to_representation(obj)
data['pagination'] = {
'page_size': obj.get_page_size(),
'max_page_size': obj.get_max_page_size()
}
data['design'] = {
'list_fields': obj.list_fields,
'form_fields': obj.form_fields
}
if obj.geom_field is None:
data['geom_type'] = None
self.format_options_json(obj, data)
else:
Layer = create_dblayer_model(obj)
field = Layer._meta.get_field(obj.geom_field)
data['geom_type'] = field.geom_type
data['design']['popup'] = obj.popup if obj.interactive else None
self.format_options_geojson(obj, data)
data['style'] = style_representation(obj)
data['style_rules'] = style_rules_representation(obj)
data['design']['interactive'] = obj.interactive
data['design'][
'tooltip'] = obj.tooltip if obj.interactive else None
data['design']['cluster'] = json.loads(
obj.cluster_options or '{}') if obj.cluster_enabled else None
if obj.wms_as_reference and obj.shapetype:
path = reverse('content-wms', kwargs={'name': obj.name})
url = url_slash_join(settings.GISCUBE_URL,
remove_app_url(path))
reference = {
'title': data['title'],
'url': url,
'type': 'WMS',
'auth': 'token' if not obj.anonymous_view else None,
'options': {
'layers': data['name'],
'format': 'image/png',
'transparent': True,
'uppercase': True
},
'refresh': True
}
data['references'].insert(0, reference)
return data
def test_bulk_modificationuser(self):
field = self.layer.fields.filter(name='modificationuser').first()
field.widget = DataBaseLayerField.WIDGET_CHOICES.modificationuser
field.readonly = True
field.save()
code = 'A101'
self.login_test_user()
data = {
'ADD': [
{
'code': code,
'address': 'C/ Jaume 100, Girona',
'geometry': 'POINT (0 10)'
}
],
'UPDATE': [],
'DELETE': []
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 200)
Location = create_dblayer_model(self.layer)
obj = Location.objects.get(code=code)
self.assertIsNone(obj.modificationuser)
self.login_dev_user()
data = {
'ADD': [],
'UPDATE': [
{
'code': code,
'geometry': 'POINT (0 10)'
},
],
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 200)
obj = Location.objects.get(code=code)
self.assertTrue(obj.modificationuser, 'test_user')
def test_bulk_update_without_geometry(self):
old_geom = list(self.locations[5].geometry.coords)
data = {
'ADD': [],
'UPDATE': [{
'code': self.locations[5].code,
'address': 'C/ Martí 5, Girona'
}],
'DELETE': []
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 200)
Location = create_dblayer_model(self.layer)
obj = Location.objects.get(code=self.locations[5].code)
self.assertEqual(old_geom, list(obj.geometry.coords))
self.assertEqual(obj.address, 'C/ Martí 5, Girona')
def test_add_image(self):
self.login_test_user()
url = reverse('content-list', kwargs={'name': self.layer.name})
path = 'tests/files/giscube_01.png'
f = open(path, 'rb')
data = {'code': '001', 'name': 'Abies alba', 'image': f}
response = self.client.post(url, data)
f.close()
self.assertEqual(response.status_code, 201)
Model = create_dblayer_model(self.layer)
storage = Model._meta.get_field('image').storage
thumbnail_storage = storage.get_thumbnail_storage()
self.assertTrue(
os.path.isfile(os.path.join(storage.location, 'giscube_01.png')))
self.assertTrue(
os.path.isfile(
os.path.join(thumbnail_storage.location,
'%s.thumbnail.png' % 'giscube_01.png')))
def get_queryset(qs, field, request):
from layerserver.model_legacy import create_dblayer_model
from layerserver.models import DataBaseLayer
if field.config.get('count') is True:
dblayer = field.config['dblayer']
related_layer = DataBaseLayer.objects.filter(name=dblayer).first()
if not related_layer:
msg = 'Invalid configuration for DataBaseLayerVirtualField: %s.%s. %s doesn\'t exist' % (
field.layer.name, field.name, dblayer)
raise Exception(msg)
dblayer_fk = field.config['dblayer_fk']
related_model = create_dblayer_model(related_layer)
filter = {dblayer_fk: OuterRef(field.config['to_field'])}
items = related_model.objects.filter(
**filter).order_by().values(dblayer_fk)
count_items = items.annotate(
count=Count(dblayer_fk)).values('count')
qs = qs.annotate(
**{field.name: Coalesce(Subquery(count_items), Value(0))})
return qs
def test_urls(self):
self.login_test_user()
url = reverse('content-list', kwargs={'name': self.layer.name})
path = 'tests/files/giscube_01.png'
f = open(path, 'rb')
data = {'code': '001', 'name': 'Abies alba', 'image': f}
response = self.client.post(url, data)
f.close()
self.assertEqual(response.status_code, 201)
result = response.json()
c = Client()
response = c.get(result['image']['src'])
self.assertEqual(response.status_code, 200)
Model = create_dblayer_model(self.layer)
storage = Model._meta.get_field('image').storage
thumbnail_storage = storage.get_thumbnail_storage()
image = result['image']['thumbnail'].split('/')[-1].split('?')[0]
image_path = os.path.join(thumbnail_storage.location, image)
self.assertTrue(os.path.exists(image_path))
c = Client()
response = c.get(result['image']['thumbnail'])
self.assertTrue(os.path.exists(image_path))
self.assertEqual(response.status_code, 200)
url = reverse('content-list', kwargs={'name': self.layer.name})
response = self.client.get(url)
result = response.json()
self.assertEqual(response.status_code, 200)
for item in result['data']:
c = Client()
response = c.get(item['image']['src'])
self.assertEqual(response.status_code, 200)
c = Client()
response = c.get(item['image']['thumbnail'])
self.assertEqual(response.status_code, 200)
def setUp(self):
super(self.__class__, self).setUp()
conn = DBConnection()
conn.alias = 'test_connection'
conn.engine = settings.DATABASES['default']['ENGINE']
conn.name = settings.DATABASES['default']['NAME']
conn.user = settings.DATABASES['default']['USER']
conn.password = settings.DATABASES['default']['PASSWORD']
conn.host = settings.DATABASES['default']['HOST']
conn.port = settings.DATABASES['default']['PORT']
conn.save()
layer = DataBaseLayer()
layer.db_connection = conn
layer.name = 'tests_location_25831'
layer.table = 'tests_location_25831'
layer.srid = 25831
layer.pk_field = 'code'
layer.geom_field = 'geometry'
layer.anonymous_view = True
layer.anonymous_add = True
layer.anonymous_update = True
layer.anonymous_delete = True
layer.save()
self.layer = layer
self.locations = []
Location = create_dblayer_model(layer)
self.Location = Location
location = Location()
location.code = 'C001'
location.address = 'C/ Major 1, Salt'
location.geometry = 'POINT(482984.669856201 4647181.21886241)'
location.save()
self.locations.append(location)
def setUp(self):
super(self.__class__, self).setUp()
conn = DBConnection()
conn.alias = 'conn'
conn.engine = settings.DATABASES['default']['ENGINE']
conn.name = settings.DATABASES['default']['NAME']
conn.user = settings.DATABASES['default']['USER']
conn.password = settings.DATABASES['default']['PASSWORD']
conn.host = settings.DATABASES['default']['HOST']
conn.port = settings.DATABASES['default']['PORT']
conn.save()
layer = DataBaseLayer()
layer.db_connection = conn
layer.name = 'tests_specie'
layer.table = 'tests_specie'
layer.pk_field = 'id'
layer.save()
self.layer = layer
Specie = create_dblayer_model(layer)
specie = Specie()
specie.code = 'quercusilex'
specie.name = 'Quercus ilex'
specie.save()
self.specie = specie
self.SpecienModel = Specie
permission = DBLayerUser()
permission.user = self.test_user
permission.layer = self.layer
permission.can_view = True
permission.can_add = True
permission.can_update = True
permission.can_delete = True
permission.save()
def test_bulk_ok_geojson(self):
data = {
'ADD': [{
'type': 'Feature',
'geometry': {
'type': 'Point',
'coordinates': [0.0, 10.0]
},
'properties': {
'code': 'A101',
'address': 'C/ Jaume 100, Girona'
}
}, {
'type': 'Feature',
'geometry': {
'type': 'Point',
'coordinates': [11.0, 10.0]
},
'properties': {
'code': 'A102',
'address': 'C/ Jaume 100, Girona'
}
}],
'UPDATE': [{
'type': 'Feature',
'id': self.locations[2].code,
'geometry': {
'type': 'Point',
'coordinates': [0, 10]
},
'properties': {}
}, {
'type': 'Feature',
'id': self.locations[5].code,
'geometry': {
'type': 'Point',
'coordinates': [11, 10]
},
'properties': {
'address': 'C/ Cor de Maria 5, Girona'
}
}, {
'type': 'Feature',
'id': self.locations[1].code,
'geometry': {
'type': 'Point',
'coordinates': [11, 10]
},
'properties': {
'address': 'C/ Cor de Maria 1, Girona'
}
}],
'DELETE': [self.locations[9].code, self.locations[10].code]
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 200)
Location = create_dblayer_model(self.layer)
obj = Location.objects.get(code=data['ADD'][0]['properties']['code'])
self.assertEqual(list(obj.geometry.coords),
data['ADD'][0]['geometry']['coordinates'])
self.assertEqual(obj.address, data['ADD'][0]['properties']['address'])
obj = Location.objects.get(code=data['ADD'][1]['properties']['code'])
self.assertEqual(list(obj.geometry.coords),
data['ADD'][1]['geometry']['coordinates'])
self.assertEqual(obj.address, data['ADD'][1]['properties']['address'])
obj = Location.objects.get(code=self.locations[2].code)
self.assertEqual(list(obj.geometry.coords),
data['UPDATE'][0]['geometry']['coordinates'])
obj = Location.objects.get(code=self.locations[5].code)
self.assertEqual(list(obj.geometry.coords),
data['UPDATE'][1]['geometry']['coordinates'])
self.assertEqual(obj.address,
data['UPDATE'][1]['properties']['address'])
obj = Location.objects.get(code=self.locations[1].code)
self.assertEqual(list(obj.geometry.coords),
data['UPDATE'][2]['geometry']['coordinates'])
self.assertEqual(obj.address,
data['UPDATE'][2]['properties']['address'])
self.assertEqual(
0,
Location.objects.filter(code__in=data['DELETE']).count())
def test_bulk_undo_update(self):
self.login_test_user()
Model = create_dblayer_model(self.layer)
files = ['giscube_01.png', 'bad name.jpg']
test_files = []
i = 0
for filename in files:
test_model = Model()
test_model.code = 'B%s' % i
test_model.geometry = 'POINT (0 10)'
path = 'tests/files/%s' % filename
f = open(path, 'rb')
test_model.image.save(name=filename, content=File(f))
test_model.save()
f.close()
test_files.append(test_model)
i += 1
url = reverse('user_assets-list')
files = ['2210571.jpg', 'giscube_01.png']
assets = {}
for filename in files:
path = 'tests/files/%s' % filename
f = open(path, 'rb')
data = {'file': f}
response = self.client.post(url, data)
f.close()
assets[filename] = response.data
data = {
'ADD': [{
'code': 'C1',
'geometry': 'POINT (0 10)',
'image': assets['2210571.jpg']['file']
}],
'UPDATE': [
{
'code': 'B0',
'geometry': 'POINT (0 63)',
'image': assets['giscube_01.png']['file']
},
{
'code': 'XX',
'geometry': 'POINT (0 63)',
'image': assets['giscube_01.png']['file']
},
],
'DELETE': []
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 400)
dirs, files = Model._meta.get_field('image').storage.listdir('.')
self.assertEqual(len(files), 2)
files.sort()
self.assertEqual(files, ['bad_name.jpg', 'giscube_01.png'])
dirs, files = Model._meta.get_field(
'image').storage.get_thumbnail_storage().listdir('.')
self.assertEqual(len(files), 2)
self.assertEqual(
sorted(files),
sorted(
['giscube_01.png.thumbnail.png',
'bad_name.jpg.thumbnail.png']))
updated = Model.objects.get(code='B0')
self.assertEqual(10, updated.geometry.y)
def test_bulk_images(self):
self.login_test_user()
Model = create_dblayer_model(self.layer)
test_files = self.add_test_files([
'giscube_01.png', 'bad name.jpg', 'giscube_02.png',
'giscube_03.png'
])
self.assertTrue(os.path.exists(test_files[1].image.path))
thumbnail = test_files[1].image.storage.get_thumbnail(
test_files[1].image.name)
self.assertTrue(os.path.exists(thumbnail['path']))
self.assertEqual(
'%s%s' % (self.thumbnail_base_url, 'bad_name.jpg.thumbnail.png'),
thumbnail['url'])
url = reverse('user_assets-list')
files = ['2210571.jpg', 'giscube_01.png']
assets = {}
for filename in files:
path = 'tests/files/%s' % filename
f = open(path, 'rb')
data = {'file': f}
response = self.client.post(url, data)
f.close()
assets[filename] = response.data
image_to_update = Model.objects.get(code='B1').image.path
self.assertTrue(os.path.exists(image_to_update))
images_to_delete = Model.objects.get(
code=test_files[2].code).image.path
self.assertTrue(os.path.exists(images_to_delete))
data = {
'ADD': [{
'code': 'C1',
'name': 'Abies alba',
'image': assets['2210571.jpg']['file']
}],
'UPDATE': [
{
'code': 'B2',
'image': None
},
{
'code': 'B1',
'name': 'Bur Oak',
'image': assets['giscube_01.png']['file']
},
],
'DELETE': [test_files[3].code]
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, 200)
obj = Model.objects.get(code='C1')
self.assertTrue(os.path.exists(obj.image.path))
self.assertTrue(obj.image.name.endswith('2210571.jpg'))
obj = Model.objects.get(code='B1')
self.assertEqual(obj.name, 'Bur Oak')
self.assertTrue(os.path.exists(obj.image.path))
self.assertFalse(obj.image.name.endswith('giscube_01.png'))
self.assertTrue('giscube_01' in obj.image.name)
self.assertFalse(os.path.exists(image_to_update))
self.assertTrue(
Model.objects.filter(code=test_files[3].code).first() is None)
self.assertFalse(os.path.exists(images_to_delete))
dirs, files = Model._meta.get_field('image').storage.listdir('.')
self.assertEqual(len(files), 3)
for f in files:
name = f.split('.')[0]
self.assertTrue('giscube_01' in name or 'bad_name' in name
or '2210571' in name)
dirs, files = Model._meta.get_field(
'image').storage.get_thumbnail_storage().listdir('.')
self.assertEqual(len(files), 3)
for f in files:
name = f.split('.')[0]
self.assertTrue('giscube_01' in name or 'bad_name' in name
or '2210571' in name)
f.endswith('.thumbnail.png')
self.assertEqual(UserAsset.objects.all().count(), 0)
def setUp(self):
super(self.__class__, self).setUp()
settings.LAYERSERVER_PAGE_SIZE = 5
settings.LAYERSERVER_MAX_PAGE_SIZE = 10
conn = DBConnection()
conn.alias = 'test'
conn.engine = settings.DATABASES['default']['ENGINE']
conn.name = settings.DATABASES['default']['NAME']
conn.user = settings.DATABASES['default']['USER']
conn.password = settings.DATABASES['default']['PASSWORD']
conn.host = settings.DATABASES['default']['HOST']
conn.port = settings.DATABASES['default']['PORT']
conn.save()
layer = DataBaseLayer()
layer.db_connection = conn
layer.name = 'tests_location_25831'
layer.table = 'tests_location_25831'
layer.srid = 25831
layer.pk_field = 'code'
layer.geom_field = 'geometry'
layer.anonymous_view = True
layer.anonymous_add = True
layer.anonymous_update = True
layer.anonymous_delete = True
layer.save()
self.layer = layer
# X,Y,lng,lat, address
data = [
(485984.399179716, 4646678.69635524, 2.8308397, 41.9719769,
'Carrer de Montori, 6, Girona'),
(486004.280534943, 4646672.62826433, 2.8310798, 41.9719226,
'Carrer de Montori, 12, Girona'),
(486015.159965428, 4646685.57498505, 2.8312108, 41.9720394,
'Carrer de Montori, 17, Girona'),
(485981.063816979, 4646697.33357378, 2.830799, 41.9721447,
'Carrer del Castellet, 1, Girona'),
(486025.905078693, 4646718.69591949, 2.8313397, 41.9723379,
'Carrer del Turó Rodó, 24, Girona'),
(485976.301483811, 4646685.65164834, 2.8307418, 41.9720394,
'Carrer de Montori, 7, Girona'),
(486036.873361096, 4646679.99190294, 2.831473, 41.9719895,
'Carrer de Montori, 23, Girona'),
(485991.335509501, 4646704.60788712, 2.8309228, 41.9722104,
'Carrer de Sant Grau, 3, Girona'),
(485995.924639975, 4646687.31164811, 2.8309786, 41.9720547,
'Carrer de Montori, 9, Girona'),
(485971.231262542, 4646664.92148798, 2.8306811, 41.9718526,
'Carrer de Montori, 2, Girona'),
(485997.86065962, 4646673.30709788, 2.8310023, 41.9719286,
'Carrer de Montori, 10, Girona'),
(485991.234154363, 4646674.24171126, 2.8309223, 41.9719369,
'Carrer de Montori, 8, Girona'),
(486038.970629009, 4646714.22905804, 2.8314975, 41.9722979,
'Carrer del Turó Rodó, 27, Girona'),
(486029.087115901, 4646714.71482487, 2.8313782, 41.9723021,
'Carrer del Turó Rodó, 29, Girona'),
(486009.346425706, 4646699.62048077, 2.8311403, 41.9721658,
'Carrer de Montori, 13, Girona'),
(486032.850809002, 4646682.10936383, 2.8314244, 41.9720085,
'Carrer de Montori, 21, Girona'),
(486009.503670912, 4646720.54909947, 2.8311417, 41.9723543,
'Carrer de Sant Grau, 7, Girona'),
(485997.896958484, 4646700.10937757, 2.8310021, 41.97217,
'Carrer de Sant Grau, 4, Girona'),
(486011.821936575, 4646698.69406302, 2.8311702, 41.9721575,
'Carrer de Montori, 11, Girona'),
(486023.688015233, 4646682.56041124, 2.8313138, 41.9720124,
'Carrer de Montori, 19, Girona'),
(486003.516233289, 4646684.19897165, 2.8310703, 41.9720268,
'Carrer de Montori, 15, Girona'),
(485969.753316113, 4646680.10204534, 2.8306629, 41.9719893,
'Carrer de Montori, 5, Girona'),
(485976.833113544, 4646673.75941402, 2.8307485, 41.9719323,
'Carrer de Montori, 4, Girona'),
(485981.073650482, 4646714.89831056, 2.8307987, 41.9723029,
'Carrer del Castellet, 4, Girona'),
(485984.756663944, 4646704.48763906, 2.8308434, 41.9722092,
'Carrer del Castellet, 2, Girona'),
(485995.585985817, 4646708.84080015, 2.830974, 41.9722486,
'Carrer de Sant Grau, 5, Girona'),
(486000.922999553, 4646713.66002545, 2.8310383, 41.9722921,
'Carrer de Sant Grau, 5A, Girona'),
(486013.232808288, 4646666.24866927, 2.831188, 41.9718653,
'Carrer de Montori, 14, Girona'),
(485975.306531153, 4646710.45744782, 2.8307292, 41.9722628,
'Carrer del Castellet, 3, Girona'),
]
self.locations = []
Location = create_dblayer_model(layer)
self.Location = Location
for i, item in enumerate(data):
location = Location()
location.code = 'B%s' % i
location.address = item[4]
location.geometry = 'POINT(%s %s)' % (item[0], item[1])
location.save()
self.locations.append(location)
def test_sequence_int(self):
sql = """
CREATE SEQUENCE tree_int_code_seq
START WITH 1
INCREMENT BY 1
NO MINVALUE
NO MAXVALUE
CACHE 1;
CREATE TABLE tree_int (
id SERIAL NOT NULL,
code integer NOT NULL
default (nextval('tree_int_code_seq'::regclass)),
name character varying(12) default 'Hell")o',
description character varying(250)
);
"""
with self.conn.get_connection().cursor() as cursor:
cursor.execute(sql)
self.sql_to_delete = [
'DROP TABLE tree_int;',
'DROP SEQUENCE tree_int_code_seq;',
]
layer = DataBaseLayer()
layer.db_connection = self.conn
layer.slug = 'tree_int'
layer.name = 'tree_int'
layer.table = 'tree_int'
layer.pk_field = 'id'
layer.anonymous_view = True
layer.anonymous_add = True
layer.anonymous_update = True
layer.anonymous_delete = True
layer.save()
self.layer = layer
field = self.layer.fields.filter(name='code').first()
field.blank = True
field.save()
Tree = create_dblayer_model(self.layer)
obj = Tree()
obj.description = 'test 1'
obj.save()
self.assertEqual(Tree.objects.last().code, 1)
data = {
'ADD': [
{
'description': 'test 2'
},
],
'UPDATE': [],
'DELETE': []
}
url = reverse('content-bulk', kwargs={'name': self.layer.name})
response = self.client.post(url, data, format='json')
# print(response.json())
self.assertEqual(response.status_code, 200)
self.assertEqual(Tree.objects.last().code, 2)
