def response_editing_mode(self, request):
"""
Perform editing operation, returns features data and features locked.
:param request: API request object
"""
super().response_data_mode(request)
# lock features and get:
feature_ids = [
str(server_fid(f, self.metadata_layer.qgis_layer.dataProvider()))
for f in self.features
]
features_locked = self.metadata_layer.lock.lockFeatures(feature_ids)
# update response
self.results.update({'featurelocks': features_locked})
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
def response_data_mode(self, request, export_features=False):
"""
Query layer and return data
:param request: DjangoREST API request object
:param formatter: Boolean, default False, True for to use QgsJsonExport.exportFeatures method
:return: response dict data
"""
# Create the QGIS feature request, it will be passed through filters
# and to the final QGIS API get features call.
qgis_feature_request = QgsFeatureRequest()
# Prepare arguments for the get feature call
kwargs = {}
# Apply filter backends, store original subset string
original_subset_string = self.metadata_layer.qgis_layer.subsetString()
if hasattr(self, 'filter_backends'):
try:
for backend in self.filter_backends:
backend().apply_filter(request, self.metadata_layer,
qgis_feature_request, self)
except Exception as e:
raise APIException(e)
# Paging cannot be a backend filter
if 'page' in request.query_params:
kwargs['page'] = request.query_params.get('page')
kwargs['page_size'] = request.query_params.get('page_size', 10)
# Make sure we have all attrs we need to build the server FID
provider = self.metadata_layer.qgis_layer.dataProvider()
if qgis_feature_request.flags() & QgsFeatureRequest.SubsetOfAttributes:
attrs = qgis_feature_request.subsetOfAttributes()
for attr_idx in provider.pkAttributeIndexes():
if attr_idx not in attrs:
attrs.append(attr_idx)
qgis_feature_request.setSubsetOfAttributes(attrs)
self.features = get_qgis_features(self.metadata_layer.qgis_layer,
qgis_feature_request, **kwargs)
# Reproject feature if layer CRS != Project CRS
if self.reproject:
for f in self.features:
self.reproject_feature(f)
ex = QgsJsonExporter(self.metadata_layer.qgis_layer)
# If 'unique' request params is set,
# api return a list of unique
# field name sent with 'unique' param.
# --------------------------------------
# IDEA: for big data it'll be iterate over features to get unique
# c++ iteration is fast. Instead memory layer with too many features can be a problem.
if 'unique' in request.query_params:
vl = QgsVectorLayer(
QgsWkbTypes.displayString(
self.metadata_layer.qgis_layer.wkbType()),
"temporary_vector", "memory")
pr = vl.dataProvider()
# add fields
pr.addAttributes(self.metadata_layer.qgis_layer.fields())
vl.updateFields(
) # tell the vector layer to fetch changes from the provider
res = pr.addFeatures(self.features)
uniques = vl.uniqueValues(
self.metadata_layer.qgis_layer.fields().indexOf(
request.query_params.get('unique')))
values = []
for u in uniques:
try:
if u:
values.append(json.loads(QgsJsonUtils.encodeValue(u)))
except Exception as e:
logger.error(f'Response vector widget unique: {e}')
continue
# sort values
values.sort()
self.results.update({'data': values, 'count': len(values)})
del (vl)
else:
ex.setTransformGeometries(False)
# check for formatter query url param and check if != 0
if 'formatter' in request.query_params:
formatter = request.query_params.get('formatter')
if formatter.isnumeric() and int(formatter) == 0:
export_features = False
else:
export_features = True
if export_features:
feature_collection = json.loads(
ex.exportFeatures(self.features))
else:
# to exclude QgsFormater used into QgsJsonExporter is necessary build by hand single json feature
ex.setIncludeAttributes(False)
feature_collection = {
'type': 'FeatureCollection',
'features': []
}
for feature in self.features:
fnames = []
date_fields = []
for f in feature.fields():
fnames.append(f.name())
if f.typeName() in ('date', 'datetime', 'time'):
date_fields.append(f)
jsonfeature = json.loads(
ex.exportFeature(
feature, dict(zip(fnames, feature.attributes()))))
# Update date and datetime fields value if widget is active
if len(date_fields) > 0:
for f in date_fields:
field_idx = self.metadata_layer.qgis_layer.fields(
).indexFromName(f.name())
options = self.metadata_layer.qgis_layer.editorWidgetSetup(
field_idx).config()
if 'field_iso_format' in options and not options[
'field_iso_format']:
try:
jsonfeature['properties'][f.name()] = feature.attribute(f.name())\
.toString(options['field_format'])
except:
pass
feature_collection['features'].append(jsonfeature)
# Change media
self.change_media(feature_collection)
# Patch feature IDs with server featureIDs
fids_map = {}
for f in self.features:
fids_map[f.id()] = server_fid(f, provider)
for i in range(len(feature_collection['features'])):
f = feature_collection['features'][i]
f['id'] = fids_map[f['id']]
self.results.update(
APIVectorLayerStructure(
**{
'data':
feature_collection,
'count':
count_qgis_features(self.metadata_layer.qgis_layer,
qgis_feature_request, **kwargs),
'geometryType':
self.metadata_layer.geometry_type,
}).as_dict())
# FIXME: add extra fields data by signals and receivers
# FIXME: featurecollection = post_serialize_maplayer.send(layer_serializer, layer=self.layer_name)
# FIXME: Not sure how to map this to the new QGIS API
# Restore the original subset string
self.metadata_layer.qgis_layer.setSubsetString(original_subset_string)