def test_unique(self):
"""Test unique project level constraints"""
# Note: in QGIS 3.10 DB-level unique constraints are not supported by OGR and spatialite providers
# in QGIS 3.16 they are supported
# Nothing is set, only return NOT NULL errors
feature = self._feature_factory({}, 'point( 9 45 )')
errors = feature_validator(feature, self.validator_project_test_unique)
self.assertEqual(set(errors.keys()), self.not_nullable_fields)
# Clone the existing feature
feature = self.validator_project_test.getFeature(1)
# Null the id to simulate a new feature added
feature.setId(0)
feature.setAttribute(0, 0) # fid
errors = feature_validator(feature, self.validator_project_test_unique)
# 3.16 also supports DB-level unique on OGR layers, 3.10 does not
if Qgis.QGIS_VERSION_INT < 31600:
self.assertEqual(
set(errors.keys()),
self.nullable_fields.difference(('bool_nullable', )))
else:
self.assertEqual(
set(errors.keys()),
self.nullable_fields.union(self.unique_fields).difference(
('bool_nullable', 'fid')))
for k in errors.keys():
self.assertEqual(errors[k], ['Field value must be UNIQUE'])
def test_expression(self):
"""Test project level expression constraints"""
feature = self._feature_factory(
{
# To avoid other errors
'text_not_nullable': 'a text',
'integer_not_nullable': 12345,
'long_not_nullable': 12345,
'float_not_nullable': 12345,
'bool_not_nullable': True,
'date_not_nullable': '2020-02-01',
'datetime_not_nullable': '2020-02-01 00:00:00',
# The real expression test, check is != 123 or 1000-02-03
'text_nullable': '124',
'integer_nullable': 124,
'long_nullable': 124,
'float_nullable': 124,
'date_nullable': '1000-02-04',
'datetime_nullable': '1000-02-04 00:00:00'
},
'point( 9 45 )')
errors = feature_validator(feature,
self.validator_project_test_expressions)
self.assertEqual(errors, {})
feature.setAttribute('text_nullable', '123')
errors = feature_validator(feature,
self.validator_project_test_expressions)
self.assertEqual(errors, {
'text_nullable':
["My constraint Expression: text_nullable != '123'"]
})
# Clone the existing feature
feature = self.validator_project_test.getFeature(1)
# Null the id to simulate a new feature added
feature.setId(0)
feature.setAttribute(0, 0) # fid
errors = feature_validator(feature,
self.validator_project_test_expressions)
self.assertEqual(errors['text_nullable'][0],
"My constraint Expression: text_nullable != '123'")
self.assertEqual(
errors['integer_nullable'][0],
"Expression check violation Expression: integer_nullable != 123")
self.assertEqual(
errors['long_nullable'][0],
"Expression check violation Expression: long_nullable != 123")
self.assertEqual(
errors['float_nullable'][0],
"Expression check violation Expression: float_nullable != 123")
self.assertEqual(
errors['date_nullable'][0],
"Expression check violation Expression: date_nullable != '1000-02-03'"
)
self.assertEqual(
errors['datetime_nullable'][0],
"Expression check violation Expression: datetime_nullable != to_datetime('1000-02-03 00:00:00')"
)
def test_value_nulls(self):
"""Test value NULL and None are not passed through the type compatibility check"""
feature = self._feature_factory({
'text_nullable': None,
}, 'point( 9 45 )')
errors = feature_validator(feature, self.validator_project_test)
self.assertFalse('text_nullable' in errors)
feature = self._feature_factory({
'text_nullable': QVariant(),
}, 'point( 9 45 )')
errors = feature_validator(feature, self.validator_project_test)
self.assertFalse('text_nullable' in errors)
def test_geometry(self):
"""Test geometry type matches"""
feature = self._feature_factory()
errors = feature_validator(feature, self.validator_project_test)
self.assertFalse('geometry' in errors)
feature = self._feature_factory({}, 'NULL')
errors = feature_validator(feature, self.validator_project_test)
self.assertFalse('geometry' in errors)
feature = self._feature_factory({}, 'LINESTRING(9 45, 10 46)')
errors = feature_validator(feature, self.validator_project_test)
self.assertTrue('geometry' in errors, errors)
def test_value_types(self):
"""Test value type compatibility"""
feature = self._feature_factory(
{
'text_not_nullable': 123,
'integer_not_nullable': 'not an int',
'long_not_nullable': 'not a number',
'float_not_nullable': 'not a number',
# Note: this is actually convertible to bool
'bool_not_nullable': 'not a boolean',
'date_not_nullable': 'not a date',
'datetime_not_nullable': 'not a datetime',
},
'point( 9 45 )')
errors = feature_validator(feature, self.validator_project_test)
self.assertEqual(
errors, {
'integer_not_nullable':
["Field value 'not an int' cannot be converted to int"],
'long_not_nullable': [
"Field value 'not a number' cannot be converted to qlonglong"
],
'float_not_nullable':
["Field value 'not a number' cannot be converted to double"],
'date_not_nullable':
["Field value 'not a date' cannot be converted to QDate"],
'datetime_not_nullable': [
"Field value 'not a datetime' cannot be converted to QDateTime"
]
})
def test_not_null(self):
"""Test not null DB level and project level constraints"""
feature = self._feature_factory()
errors = feature_validator(feature, self.validator_project_test)
self.assertEqual(set(errors.keys()), self.not_nullable_fields)
feature = self._feature_factory()
errors = feature_validator(feature,
self.validator_project_test_not_null)
self.assertEqual(set(errors.keys()),
self.not_nullable_fields.union(self.nullable_fields))
# NOT NULL with defaults
feature = self._feature_factory()
errors = feature_validator(feature,
self.validator_project_test_defaults)
self.assertEqual(set(errors.keys()), set())
def test_unique(self):
"""Test unique project level constraints"""
# Note: DB-level unique constraints are not supported by OGR and spatialite providers
# Nothing is set, only return NOT NULL errors
feature = self._feature_factory({}, 'point( 9 45 )')
errors = feature_validator(feature, self.validator_project_test_unique)
self.assertEqual(set(errors.keys()), self.not_nullable_fields)
# Clone the existing feature
feature = self.validator_project_test.getFeature(1)
# Null the id to simulate a new feature added
feature.setId(0)
feature.setAttribute(0, 0) # fid
errors = feature_validator(feature, self.validator_project_test_unique)
self.assertEqual(set(errors.keys()),
self.nullable_fields.difference(('bool_nullable', )))
for k in errors.keys():
self.assertEqual(errors[k], ['Field value must be UNIQUE'])
def save_vector_data(self,
metadata_layer,
post_layer_data,
has_transactions,
post_save_signal=True,
**kwargs):
"""Save vector editing data
:param metadata_layer: metadata of the layer being edited
:type metadata_layer: MetadataVectorLayer
:param post_layer_data: post data with 'add', 'delete' etc.
:type post_layer_data: dict
:param has_transactions: true if the layer support transactions
:type has_transactions: bool
:param post_save_signal: if this is a post_save_signal call, defaults to True
:type post_save_signal: bool, optional
"""
# get initial featurelocked
metadata_layer.lock.getInitialFeatureLockedIds()
# get lockids from client
metadata_layer.lock.setLockeFeaturesFromClient(
post_layer_data['lockids'])
# data for response
insert_ids = list()
lock_ids = list()
# FIXME: check this out
# for add check if is a metadata_layer and referenced field is a pk
is_referenced_field_is_pk = 'referenced_layer_insert_ids' in kwargs and kwargs['referenced_layer_insert_ids'] \
and hasattr(metadata_layer, 'referenced_field_is_pk') \
and metadata_layer.referenced_field_is_pk
# Get the layer
qgis_layer = metadata_layer.qgis_layer
for mode_editing in (EDITING_POST_DATA_ADDED,
EDITING_POST_DATA_UPDATED):
if mode_editing in post_layer_data:
for geojson_feature in post_layer_data[mode_editing]:
data_extra_fields = {'feature': geojson_feature}
# Clear any old error
qgis_layer.dataProvider().clearErrors()
# add media data
self.add_media_property(geojson_feature, metadata_layer)
# for GEOSGeometry of Django 2.2 it must add crs to feature if is not set if a geo feature
if metadata_layer.geometry_type != QGIS_LAYER_TYPE_NO_GEOM:
self.add_crs_to_feature(geojson_feature)
# reproject data if necessary
if self.reproject:
self.reproject_feature(geojson_feature, to_layer=True)
# case relation data ADD, if father referenced field is pk
if is_referenced_field_is_pk:
for newid in kwargs['referenced_layer_insert_ids']:
if geojson_feature['properties'][
metadata_layer.
referencing_field] == newid['clientid']:
geojson_feature['properties'][
metadata_layer.
referencing_field] = newid['id']
if mode_editing == EDITING_POST_DATA_UPDATED:
# control feature locked
if not metadata_layer.lock.checkFeatureLocked(
geojson_feature['id']):
raise Exception(
self.no_more_lock_feature_msg.format(
geojson_feature['id'],
metadata_layer.client_var))
# Send for validation
# Note that this may raise a validation error
pre_save_maplayer.send(self,
layer_metadata=metadata_layer,
mode=mode_editing,
data=data_extra_fields,
user=self.request.user)
# Validate and save
try:
feature = QgsFeature(qgis_layer.fields())
if mode_editing == EDITING_POST_DATA_UPDATED:
feature.setId(geojson_feature['id'])
# We use this feature for geometry parsing only:
imported_feature = QgsJsonUtils.stringToFeatureList(
json.dumps(geojson_feature),
qgis_layer.fields(),
None # UTF8 codec
)[0]
feature.setGeometry(imported_feature.geometry())
# There is something wrong in QGIS 3.10 (fixed in later versions)
# so, better loop through the fields and set attributes individually
for name, value in geojson_feature['properties'].items(
):
feature.setAttribute(name, value)
# Call validator!
errors = feature_validator(feature,
metadata_layer.qgis_layer)
if errors:
raise ValidationError(errors)
# Save the feature
if mode_editing == EDITING_POST_DATA_ADDED:
if has_transactions:
if not qgis_layer.addFeature(feature):
raise Exception(
_('Error adding feature: %s') %
', '.join(qgis_layer.dataProvider().
errors()))
else:
if not qgis_layer.dataProvider().addFeature(
feature):
raise Exception(
_('Error adding feature: %s') %
', '.join(qgis_layer.dataProvider().
errors()))
# Patch for Spatialite provider on pk
if qgis_layer.dataProvider().name(
) == 'spatialite':
pks = qgis_layer.primaryKeyAttributes()
if len(pks) > 1:
raise Exception(
_(f'Error adding feature on Spatialite provider: '
f'layer {qgis_layer.id()} has more than one pk column'
))
# update pk attribute:
feature.setAttribute(pks[0], feature.id())
elif mode_editing == EDITING_POST_DATA_UPDATED:
attr_map = {}
for name, value in geojson_feature[
'properties'].items():
if name in qgis_layer.dataProvider(
).fieldNameMap():
attr_map[qgis_layer.dataProvider().
fieldNameMap()[name]] = value
if has_transactions:
if not qgis_layer.changeAttributeValues(
geojson_feature['id'], attr_map):
raise Exception(
_('Error changing attribute values: %s'
) %
', '.join(qgis_layer.dataProvider().
errors()))
# Check for errors because of https://github.com/qgis/QGIS/issues/36583
if qgis_layer.dataProvider().errors():
raise Exception(', '.join(
qgis_layer.dataProvider().errors()))
if not feature.geometry().isNull(
) and not qgis_layer.changeGeometry(
geojson_feature['id'],
feature.geometry()):
raise Exception(
_('Error changing geometry: %s') %
', '.join(qgis_layer.dataProvider().
errors()))
else:
if not qgis_layer.dataProvider(
).changeAttributeValues(
{geojson_feature['id']: attr_map}):
raise Exception(
_('Error changing attribute values: %s'
) %
', '.join(qgis_layer.dataProvider().
errors()))
if not feature.geometry().isNull(
) and not qgis_layer.dataProvider(
).changeGeometryValues({
geojson_feature['id']:
feature.geometry()
}):
raise Exception(
_('Error changing geometry: %s') %
', '.join(qgis_layer.dataProvider().
errors()))
to_res = {}
to_res_lock = {}
if mode_editing == EDITING_POST_DATA_ADDED:
ex = QgsJsonExporter(qgis_layer)
jfeature = json.loads(ex.exportFeature(feature))
to_res.update({
'clientid': geojson_feature['id'],
# This might be the internal QGIS feature id (< 0)
'id': feature.id(),
'properties': jfeature['properties']
})
# lock news:
to_res_lock = metadata_layer.lock.modelLock2dict(
metadata_layer.lock.lockFeature(feature.id(),
save=True))
if bool(to_res):
insert_ids.append(to_res)
if bool(to_res_lock):
lock_ids.append(to_res_lock)
except ValidationError as ex:
raise ValidationError({
metadata_layer.client_var: {
mode_editing: {
'id': geojson_feature['id'],
'fields': ex.detail,
}
}
})
except Exception as ex:
raise ValidationError({
metadata_layer.client_var: {
mode_editing: {
'id': geojson_feature['id'],
'fields': str(ex),
}
}
})
# erasing feature if to do
if EDITING_POST_DATA_DELETED in post_layer_data:
for feature_id in post_layer_data[EDITING_POST_DATA_DELETED]:
# control feature locked
if not metadata_layer.lock.checkFeatureLocked(feature_id):
raise Exception(
self.no_more_lock_feature_msg.format(
feature_id, metadata_layer.client_var))
# FIXME: pre_delete_maplayer
# pre_delete_maplayer.send(metadata_layer.serializer, layer=metadata_layer.layer_id, # data=serializer.data, user=self.request.user)
qgis_layer.dataProvider().clearErrors()
if has_transactions:
if not qgis_layer.deleteFeatures(
[feature_id]) or qgis_layer.dataProvider().errors():
raise Exception(
_('Cannot delete feature: %s') %
', '.join(qgis_layer.dataProvider().errors()))
else:
if not qgis_layer.dataProvider().deleteFeatures(
[feature_id]) or qgis_layer.dataProvider().errors():
raise Exception(
_('Cannot delete feature: %s') %
', '.join(qgis_layer.dataProvider().errors()))
return insert_ids, lock_ids
def save_vector_data(self,
metadata_layer,
post_layer_data,
has_transactions,
post_save_signal=True,
**kwargs):
"""Save vector editing data
:param metadata_layer: metadata of the layer being edited
:type metadata_layer: MetadataVectorLayer
:param post_layer_data: post data with 'add', 'delete' etc.
:type post_layer_data: dict
:param has_transactions: true if the layer support transactions
:type has_transactions: bool
:param post_save_signal: if this is a post_save_signal call, defaults to True
:type post_save_signal: bool, optional
"""
# Check atomic capabilities for validation
# -----------------------------------------------
#for mode_editing in (EDITING_POST_DATA_ADDED, EDITING_POST_DATA_UPDATED, EDITING_POST_DATA_DELETED):
# try to get layer model object from metatada_layer
layer = getattr(metadata_layer, 'layer', self.layer)
if EDITING_POST_DATA_ADDED in post_layer_data and len(
post_layer_data[EDITING_POST_DATA_ADDED]) > 0:
if not self.request.user.has_perm('qdjango.add_feature', layer):
raise ValidationError(
_('Sorry but your user doesn\'t has \'Add Feature\' capability'
))
if EDITING_POST_DATA_DELETED in post_layer_data and len(
post_layer_data[EDITING_POST_DATA_DELETED]) > 0:
if not self.request.user.has_perm('qdjango.delete_feature', layer):
raise ValidationError(
_('Sorry but your user doesn\'t has \'Delete Feature\' capability'
))
if EDITING_POST_DATA_UPDATED in post_layer_data and len(
post_layer_data[EDITING_POST_DATA_UPDATED]) > 0:
if not self.request.user.has_perm('qdjango.change_feature', layer) and \
not self.request.user.has_perm('qdjango.change_attr_feature', layer):
raise ValidationError(
_('Sorry but your user doesn\'t has \'Change or Change Attributes Features\' capability'
))
# get initial featurelocked
metadata_layer.lock.getInitialFeatureLockedIds()
# get lockids from client
metadata_layer.lock.setLockeFeaturesFromClient(
post_layer_data['lockids'])
# data for response
insert_ids = list()
lock_ids = list()
# FIXME: check this out
# for add check if is a metadata_layer and referenced field is a pk
is_referenced_field_is_pk = 'referenced_layer_insert_ids' in kwargs and kwargs['referenced_layer_insert_ids'] \
and hasattr(metadata_layer, 'referenced_field_is_pk') \
and metadata_layer.referenced_field_is_pk
# Get the layer
qgis_layer = metadata_layer.qgis_layer
for mode_editing in (EDITING_POST_DATA_ADDED,
EDITING_POST_DATA_UPDATED):
if mode_editing in post_layer_data:
for geojson_feature in post_layer_data[mode_editing]:
data_extra_fields = {'feature': geojson_feature}
# Clear any old error
qgis_layer.dataProvider().clearErrors()
# add media data
self.add_media_property(geojson_feature, metadata_layer)
# for GEOSGeometry of Django 2.2 it must add crs to feature if is not set if a geo feature
if metadata_layer.geometry_type != QGIS_LAYER_TYPE_NO_GEOM:
if geojson_feature[
'geometry'] and 'crs' not in geojson_feature[
'geometry']:
geojson_feature['geometry'][
'crs'] = "{}:{}".format(
self.layer.project.group.srid.auth_name,
self.layer.project.group.srid.auth_srid)
# reproject data if necessary
if kwargs[
'reproject'] and metadata_layer.geometry_type != QGIS_LAYER_TYPE_NO_GEOM:
self.reproject_feature(geojson_feature, to_layer=True)
# case relation data ADD, if father referenced field is pk
if is_referenced_field_is_pk:
for newid in kwargs['referenced_layer_insert_ids']:
if geojson_feature['properties'][
metadata_layer.
referencing_field] == newid['clientid']:
geojson_feature['properties'][
metadata_layer.
referencing_field] = newid['id']
if mode_editing == EDITING_POST_DATA_UPDATED:
# control feature locked
if not metadata_layer.lock.checkFeatureLocked(
geojson_feature['id']):
raise Exception(
self.no_more_lock_feature_msg.format(
geojson_feature['id'],
metadata_layer.client_var))
# Send for validation
# Note that this may raise a validation error
pre_save_maplayer.send(self,
layer_metadata=metadata_layer,
mode=mode_editing,
data=data_extra_fields,
user=self.request.user)
# Validate and save
try:
original_feature = None
feature = QgsFeature(qgis_layer.fields())
if mode_editing == EDITING_POST_DATA_UPDATED:
# add patch for shapefile type, geojson_feature['id'] id int() instead of str()
# path to fix into QGIS api
geojson_feature[
'id'] = get_layer_fids_from_server_fids(
[str(geojson_feature['id'])],
qgis_layer)[0]
feature.setId(geojson_feature['id'])
# Get feature from data provider before update
original_feature = qgis_layer.getFeature(
geojson_feature['id'])
# We use this feature for geometry parsing only:
imported_feature = QgsJsonUtils.stringToFeatureList(
json.dumps(geojson_feature),
qgis_layer.fields(),
None # UTF8 codec
)[0]
feature.setGeometry(imported_feature.geometry())
# There is something wrong in QGIS 3.10 (fixed in later versions)
# so, better loop through the fields and set attributes individually
for name, value in geojson_feature['properties'].items(
):
feature.setAttribute(name, value)
# Loop again for set expressions value:
# For update store expression result to use later into update condition
field_expresion_values = {}
for qgis_field in qgis_layer.fields():
if qgis_field.defaultValueDefinition().expression(
):
exp = QgsExpression(
qgis_field.defaultValueDefinition(
).expression())
if exp.rootNode().nodeType(
) != QgsExpressionNode.ntLiteral and not exp.hasParserError(
):
context = QgsExpressionContextUtils.createFeatureBasedContext(
feature, qgis_layer.fields())
context.appendScopes(
QgsExpressionContextUtils.
globalProjectLayerScopes(qgis_layer))
result = exp.evaluate(context)
if not exp.hasEvalError():
feature.setAttribute(
qgis_field.name(), result)
# Check update if expression default value has to run also on update e not
# only on insert newone
if qgis_field.defaultValueDefinition(
).applyOnUpdate():
field_expresion_values[
qgis_field.name()] = result
elif qgis_field.typeName() in ('date', 'datetime',
'time'):
if qgis_field.typeName() == 'date':
qtype = QDate
elif qgis_field.typeName() == 'datetime':
qtype = QDateTime
else:
qtype = QTime
field_idx = qgis_layer.fields().indexFromName(
qgis_field.name())
options = qgis_layer.editorWidgetSetup(
field_idx).config()
if 'field_iso_format' in options and not options[
'field_iso_format']:
if geojson_feature['properties'][
qgis_field.name()]:
value = qtype.fromString(
geojson_feature['properties'][
qgis_field.name()],
options['field_format'])
feature.setAttribute(
qgis_field.name(), value)
# Call validator!
errors = feature_validator(feature,
metadata_layer.qgis_layer)
if errors:
raise ValidationError(errors)
# Save the feature
if mode_editing == EDITING_POST_DATA_ADDED:
if has_transactions:
if not qgis_layer.addFeature(feature):
raise Exception(
_('Error adding feature: %s') %
', '.join(qgis_layer.dataProvider().
errors()))
else:
if not qgis_layer.dataProvider().addFeature(
feature):
raise Exception(
_('Error adding feature: %s') %
', '.join(qgis_layer.dataProvider().
errors()))
# Patch for Spatialite provider on pk
if qgis_layer.dataProvider().name(
) == 'spatialite':
pks = qgis_layer.primaryKeyAttributes()
if len(pks) > 1:
raise Exception(
_(f'Error adding feature on Spatialite provider: '
f'layer {qgis_layer.id()} has more than one pk column'
))
# update pk attribute:
feature.setAttribute(
pks[0],
server_fid(feature,
qgis_layer.dataProvider()))
elif mode_editing == EDITING_POST_DATA_UPDATED:
attr_map = {}
for name, value in geojson_feature[
'properties'].items():
if name in qgis_layer.dataProvider(
).fieldNameMap():
if name in field_expresion_values:
value = field_expresion_values[name]
attr_map[qgis_layer.dataProvider().
fieldNameMap()[name]] = value
if has_transactions:
if not qgis_layer.changeAttributeValues(
geojson_feature['id'], attr_map):
raise Exception(
_('Error changing attribute values: %s'
) %
', '.join(qgis_layer.dataProvider().
errors()))
# Check for errors because of https://github.com/qgis/QGIS/issues/36583
if qgis_layer.dataProvider().errors():
raise Exception(', '.join(
qgis_layer.dataProvider().errors()))
if not feature.geometry().isNull(
) and not qgis_layer.changeGeometry(
geojson_feature['id'],
feature.geometry()):
raise Exception(
_('Error changing geometry: %s') %
', '.join(qgis_layer.dataProvider().
errors()))
else:
if not qgis_layer.dataProvider(
).changeAttributeValues(
{geojson_feature['id']: attr_map}):
raise Exception(
_('Error changing attribute values: %s'
) %
', '.join(qgis_layer.dataProvider().
errors()))
if not feature.geometry().isNull(
) and not qgis_layer.dataProvider(
).changeGeometryValues({
geojson_feature['id']:
feature.geometry()
}):
raise Exception(
_('Error changing geometry: %s') %
', '.join(qgis_layer.dataProvider().
errors()))
to_res = {}
to_res_lock = {}
if mode_editing == EDITING_POST_DATA_ADDED:
# to exclude QgsFormater used into QgsJsonjExporter is necessary build by hand single json feature
ex = QgsJsonExporter(qgis_layer)
ex.setIncludeAttributes(False)
fnames = [f.name() for f in feature.fields()]
jfeature = json.loads(
ex.exportFeature(
feature,
dict(zip(fnames, feature.attributes()))))
to_res.update({
'clientid':
geojson_feature['id'],
# This might be the internal QGIS feature id (< 0)
'id':
server_fid(
feature,
metadata_layer.qgis_layer.dataProvider()),
'properties':
jfeature['properties']
})
# lock news:
to_res_lock = metadata_layer.lock.modelLock2dict(
metadata_layer.lock.lockFeature(server_fid(
feature,
metadata_layer.qgis_layer.dataProvider()),
save=True))
if bool(to_res):
insert_ids.append(to_res)
if bool(to_res_lock):
lock_ids.append(to_res_lock)
# Send post vase signal
post_save_maplayer.send(
self,
layer_metadata=metadata_layer,
mode=mode_editing,
data=data_extra_fields,
user=self.request.user,
original_feature=original_feature,
to_res=to_res)
except ValidationError as ex:
raise ValidationError({
metadata_layer.client_var: {
mode_editing: {
'id': geojson_feature['id'],
'fields': ex.detail,
}
}
})
except Exception as ex:
raise ValidationError({
metadata_layer.client_var: {
mode_editing: {
'id': geojson_feature['id'],
'fields': str(ex),
}
}
})
# erasing feature if to do
if EDITING_POST_DATA_DELETED in post_layer_data:
fids = post_layer_data[EDITING_POST_DATA_DELETED]
# get feature fids from server fids from client.
fids = get_layer_fids_from_server_fids([str(id) for id in fids],
qgis_layer)
for feature_id in fids:
# control feature locked
if not metadata_layer.lock.checkFeatureLocked(str(feature_id)):
raise Exception(
self.no_more_lock_feature_msg.format(
feature_id, metadata_layer.client_var))
# Get feature to delete
ex = QgsJsonExporter(qgis_layer)
deleted_feature = ex.exportFeature(
qgis_layer.getFeature(feature_id))
pre_delete_maplayer.send(self,
layer_metatada=metadata_layer,
data=deleted_feature,
user=self.request.user)
qgis_layer.dataProvider().clearErrors()
if has_transactions:
if not qgis_layer.deleteFeatures(
[feature_id]) or qgis_layer.dataProvider().errors():
raise Exception(
_('Cannot delete feature: %s') %
', '.join(qgis_layer.dataProvider().errors()))
else:
if not qgis_layer.dataProvider().deleteFeatures(
[feature_id]) or qgis_layer.dataProvider().errors():
raise Exception(
_('Cannot delete feature: %s') %
', '.join(qgis_layer.dataProvider().errors()))
return insert_ids, lock_ids