def setSql(self, parameters, context, feedback):
# Database connection parameters
connection_name = QgsExpressionContextUtils.globalScope().variable('gobs_connection_name')
get_data = QgsExpressionContextUtils.globalScope().variable('gobs_get_database_data')
if get_data != 'yes':
return
# Get id, label and geometry type from chosen spatial layer
spatiallayer = self.SPATIALLAYERS[parameters[self.SPATIALLAYER]]
id_spatial_layer = int(spatiallayer.split('-')[-1].strip())
# Override spatial layer id from second number input
spatial_layer_id = self.parameterAsInt(parameters, self.SPATIALLAYER_ID, context)
if spatial_layer_id and spatial_layer_id in self.SPATIALLAYERS_DICT:
id_spatial_layer = spatial_layer_id
feedback.pushInfo(
tr('GET DATA FROM CHOSEN SPATIAL LAYER')
)
sql = "SELECT id, sl_label, sl_geometry_type FROM gobs.spatial_layer WHERE id = %s" % id_spatial_layer
[header, data, rowCount, ok, message] = fetchDataFromSqlQuery(
connection_name,
sql
)
if ok:
label = data[0][1]
message = tr('* Data has been fetched for spatial layer')
message += ' %s !' % label
feedback.pushInfo(
message
)
else:
raise QgsProcessingException(message)
# Retrieve needed data
id_spatial_layer = data[0][0]
geometry_type = data[0][2]
# Build SQL
sql = '''
SELECT
id,
so_unique_id AS code,
so_unique_label AS label,
geom::geometry({1}, 4326) AS geom
FROM gobs.spatial_object
WHERE fk_id_spatial_layer = {0}
'''.format(
id_spatial_layer,
geometry_type
)
self.SQL = sql.replace('\n', ' ').rstrip(';')
def initAlgorithm(self, config):
# INPUTS
# Database connection parameters
connection_name = QgsExpressionContextUtils.globalScope().variable(
'gobs_connection_name')
db_param = QgsProcessingParameterString(
self.CONNECTION_NAME,
tr('PostgreSQL connection to G-Obs database'),
defaultValue=connection_name,
optional=False)
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
# OUTPUTS
# Add output for status (integer)
self.addOutput(
QgsProcessingOutputNumber(self.OUTPUT_STATUS, tr('Output status')))
# Add output for message
self.addOutput(
QgsProcessingOutputString(self.OUTPUT_STRING,
tr('Output message')))
def processAlgorithm(self, progress):
ns = {}
ns["progress"] = progress
ns["scriptDescriptionFile"] = self.descriptionFile
for param in self.parameters:
ns[param.name] = param.value
for out in self.outputs:
ns[out.name] = out.value
variables = re.findall("@[a-zA-Z0-9_]*", self.script)
script = "import processing\n"
script += self.script
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope())
for var in variables:
varname = var[1:]
if context.hasVariable(varname):
script = script.replace(var, context.variable(varname))
else:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, "Cannot find variable: %s" % varname)
exec((script), ns)
for out in self.outputs:
out.setValue(ns[out.name])
def checkParameterValues(self, parameters, context):
# Check if runit is checked
run_delete = self.parameterAsBool(parameters, self.RUN_DELETE, context)
if not run_delete:
msg = tr(
'You must check the box to delete the spatial layer data !')
ok = False
return ok, msg
# Check that the connection name has been configured
connection_name = QgsExpressionContextUtils.globalScope().variable(
'gobs_connection_name')
if not connection_name:
return False, tr(
'You must use the "Configure G-obs plugin" alg to set the database connection name'
)
# Check that it corresponds to an existing connection
dbpluginclass = createDbPlugin('postgis')
connections = [c.connectionName() for c in dbpluginclass.connections()]
if connection_name not in connections:
return False, tr(
'The configured connection name does not exists in QGIS')
# Check layyer id is in the list of existing spatial layers
spatial_layer_id = self.parameterAsInt(parameters,
self.SPATIALLAYER_ID, context)
if spatial_layer_id and spatial_layer_id > 0:
if spatial_layer_id not in self.SPATIALLAYERS_DICT:
return False, tr(
'Spatial layer ID does not exists in the database')
return super(RemoveSpatialLayerData,
self).checkParameterValues(parameters, context)
def getIndicatorFields(given_serie):
"""
Get indicator data for the given serie id
"""
# GET INFORMATION of indicator
connection_name = QgsExpressionContextUtils.globalScope().variable(
'gobs_connection_name')
sql = '''
SELECT id_value_code, id_value_name, id_value_type, id_value_unit
FROM gobs.indicator AS i
WHERE id = (
SELECT s.fk_id_indicator
FROM gobs.series AS s
WHERE s.id = {0}
LIMIT 1
)
;
'''.format(given_serie)
try:
[header, data, rowCount, ok,
error_message] = fetchDataFromSqlQuery(connection_name, sql)
if not ok:
return None
else:
id_value_code = data[0][0]
id_value_name = data[0][1]
id_value_type = data[0][2]
id_value_unit = data[0][3]
except Exception:
return None
return id_value_code, id_value_name, id_value_type, id_value_unit
def processAlgorithm(self, feedback):
ns = {}
ns['feedback'] = feedback
ns['scriptDescriptionFile'] = self.descriptionFile
for param in self.parameters:
ns[param.name] = param.value
for out in self.outputs:
ns[out.name] = out.value
variables = re.findall('@[a-zA-Z0-9_]*', self.script)
script = 'import processing\n'
script += self.script
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(
QgsExpressionContextUtils.projectScope(QgsProject.instance()))
for var in variables:
varname = var[1:]
if context.hasVariable(varname):
script = script.replace(var, context.variable(varname))
else:
ProcessingLog.addToLog(
ProcessingLog.LOG_WARNING,
self.tr('Cannot find variable: {0}').format(varname))
exec((script), ns)
for out in self.outputs:
out.setValue(ns[out.name])
def processAlgorithm(self, progress):
layer = layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
expression = self.getParameterValue(self.EXPRESSION)
qExp = QgsExpression(expression)
if qExp.hasParserError():
raise GeoAlgorithmExecutionException(qExp.parserErrorString())
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields(), layer.wkbType(), layer.crs())
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope())
context.appendScope(QgsExpressionContextUtils.layerScope(layer))
count = layer.featureCount()
step = 100.0 / count if count else 1
request = QgsFeatureRequest(qExp, context)
for current, f in enumerate(layer.getFeatures(request)):
writer.addFeature(f)
progress.setPercentage(int(current * step))
del writer
def getSeries():
# List of series
sql = '''
SELECT s.id,
concat(
id_label,
' (', p.pr_label, ')',
' / Source: ', a_label,
' / Layer: ', sl_label
) AS label
FROM gobs.series s
INNER JOIN gobs.protocol p ON p.id = s.fk_id_protocol
INNER JOIN gobs.actor a ON a.id = s.fk_id_actor
INNER JOIN gobs.indicator i ON i.id = s.fk_id_indicator
INNER JOIN gobs.spatial_layer sl ON sl.id = s.fk_id_spatial_layer
ORDER BY label
'''
project = QgsProject.instance()
connection_name = QgsExpressionContextUtils.projectScope(project).variable('gobs_connection_name')
get_data = QgsExpressionContextUtils.globalScope().variable('gobs_get_database_data')
series = []
if get_data == 'yes' and connection_name in getPostgisConnectionList():
[header, data, rowCount, ok, error_message] = fetchDataFromSqlQuery(
connection_name,
sql
)
series = data
return series
def processAlgorithm(self, progress):
layer = layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
expression = self.getParameterValue(self.EXPRESSION)
qExp = QgsExpression(expression)
if qExp.hasParserError():
raise GeoAlgorithmExecutionException(qExp.parserErrorString())
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields(), layer.wkbType(), layer.crs())
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope())
context.appendScope(QgsExpressionContextUtils.layerScope(layer))
count = layer.featureCount()
step = 100.0 / count if count else 1
request = QgsFeatureRequest(qExp, context)
for current, f in enumerate(layer.getFeatures(request)):
writer.addFeature(f)
progress.setPercentage(int(current * step))
del writer
def initAlgorithm(self, config):
# INPUTS
connection_name = QgsExpressionContextUtils.globalScope().variable(
"veloroutes_connection_name")
db_param_a = QgsProcessingParameterString(
self.CONNECTION_NAME,
tr("Connexion PostgreSQL vers la base de données"),
defaultValue=connection_name,
optional=False,
)
db_param_a.setMetadata({
"widget_wrapper": {
"class":
"processing.gui.wrappers_postgis.ConnectionWidgetWrapper"
}
})
self.addParameter(db_param_a)
self.addParameter(
QgsProcessingParameterBoolean(
self.RUN_MIGRATIONS,
tr("Cocher cette option pour lancer la mise-à-jour."),
defaultValue=False,
optional=False,
))
# OUTPUTS
self.addOutput(
QgsProcessingOutputNumber(self.OUTPUT_STATUS, tr("Output status")))
self.addOutput(
QgsProcessingOutputString(self.OUTPUT_STRING,
tr("Output message")))
def processAlgorithm(self, parameters, context, feedback):
ns = {}
ns['feedback'] = feedback
ns['scriptDescriptionFile'] = self.descriptionFile
ns['context'] = context
for param in self.parameterDefinitions():
ns[param.name] = parameters[param.name()]
for out in self.outputs:
ns[out.name] = out.value
variables = re.findall('@[a-zA-Z0-9_]*', self.script)
script = 'import processing\n'
script += self.script
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope(QgsProject.instance()))
for var in variables:
varname = var[1:]
if context.hasVariable(varname):
script = script.replace(var, context.variable(varname))
else:
QgsMessageLog.logMessage(self.tr('Cannot find variable: {0}').format(varname), self.tr('Processing'), QgsMessageLog.WARNING)
exec((script), ns)
for out in self.outputs:
out.setValue(ns[out.name])
def processAlgorithm(self, feedback):
ns = {}
ns['feedback'] = feedback
ns['scriptDescriptionFile'] = self.descriptionFile
for param in self.parameters:
ns[param.name] = param.value
for out in self.outputs:
ns[out.name] = out.value
variables = re.findall('@[a-zA-Z0-9_]*', self.script)
script = 'import processing\n'
script += self.script
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope(QgsProject.instance()))
for var in variables:
varname = var[1:]
if context.hasVariable(varname):
script = script.replace(var, context.variable(varname))
else:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, 'Cannot find variable: %s' % varname)
exec((script), ns)
for out in self.outputs:
out.setValue(ns[out.name])
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# INPUTS
# Database connection parameters
connection_name = QgsExpressionContextUtils.globalScope().variable(
'raepa_connection_name')
db_param = QgsProcessingParameterString(
self.CONNECTION_NAME,
'Connection PostgreSQL à la base à RAEPA',
defaultValue=connection_name,
optional=False)
db_param.setMetadata({
'widget_wrapper': {
'class':
'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
self.addParameter(db_param)
# OUTPUTS
# Add output for status (integer)
self.addOutput(
QgsProcessingOutputNumber(self.OUTPUT_STATUS, 'Statut de sortie'))
# Add output for message
self.addOutput(
QgsProcessingOutputString(self.OUTPUT_STRING, 'Message de sortie'))
def setSql(self, parameters, context, feedback):
get_data = QgsExpressionContextUtils.globalScope().variable(
'gobs_get_database_data')
if get_data != 'yes':
return
# Build SQL
sql = '''
SELECT
s.id,
id_label AS indicator,
id_paths AS indicator_paths,
a_label AS actor_source,
sl_label AS spatial_layer,
pr_label AS protocol,
count(o.id) AS nb_observation,
min(o.ob_timestamp) AS min_date,
max(o.ob_timestamp) AS max_date
FROM gobs.series s
INNER JOIN gobs.observation o ON o.fk_id_series = s.id
INNER JOIN gobs.actor a ON a.id = s.fk_id_actor
INNER JOIN gobs.indicator i ON i.id = s.fk_id_indicator
INNER JOIN gobs.spatial_layer sl ON sl.id = s.fk_id_spatial_layer
INNER JOIN gobs.protocol p ON p.id = s.fk_id_protocol
GROUP BY s.id, id_label, id_paths, a_label, sl_label, pr_label
'''
self.SQL = sql.replace('\n', ' ').rstrip(';')
def checkParameterValues(self, parameters, context):
# Check that the connection name has been configured
connection_name = QgsExpressionContextUtils.globalScope().variable(
'raepa_connection_name')
if not connection_name:
msg = 'Vous devez utiliser le l\'algorithme de configuration du plugin pour paramétrer le nom de connexion.'
return False, msg
# Check that it corresponds to an existing connection
dbpluginclass = createDbPlugin('postgis')
connections = [c.connectionName() for c in dbpluginclass.connections()]
if connection_name not in connections:
msg = 'La connexion "{}" n\'existe pas dans QGIS : {}'.format(
connection_name, ', '.join(connections))
return False, msg
# Check database content
ok, msg = self.checkSchema(parameters, context)
if not ok:
return False, msg
# Check inputs
if len(parameters[self.CODE]) != 3:
return False, 'Le nom abbrégé doit faire 3 exactement caractères.'
if len(parameters[self.SIREN]) != 9:
return False, "Le SIREN doit faire exactement 9 caractères."
return super(CreateDatabaseStructure,
self).checkParameterValues(parameters, context)
def __init__(self, parentInstance, parent=None):
"""Constructor."""
super(mapillarySettings, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.parentInstance = parentInstance
self.iface = parentInstance.iface
self.setWindowTitle("go2mapillary settings")
self.fileWidget.setStorageMode(QgsFileWidget.SaveFile)
self.fileWidget.setFilter("SHP files (*.shp)")
self.buttonBox.accepted.connect(self.applySettings)
self.addCategoryButton.clicked.connect(self.addCategoryAction)
self.removeCategoryButton.clicked.connect(self.removeCategoryAction)
self.tableWidget.setColumnWidth(1, 150)
self.newCategoryEdit.setMaxLength(20)
self.settings = {
'sample_source': 'memory',
'auto_open_form': True,
'categories': {
'cat_a': '#ff0000',
'cat_b': '#0000ff',
'cat_c': '#00ff00',
}
}
if not QgsExpressionContextUtils.globalScope().hasVariable(
'mapillarySettings'):
QgsExpressionContextUtils.setGlobalVariable(
"mapillarySettings", json.dumps(self.settings))
self.loadSettings()
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
# Database connection parameters
connection_name = QgsExpressionContextUtils.globalScope().variable('raepa_connection_name')
# Set SQL
self.setSql(parameters, context, feedback)
feedback.pushInfo(self.SQL)
# Run SQL
[header, data, rowCount, ok, error_message] = fetchDataFromSqlQuery(
connection_name,
self.SQL
)
if ok:
msg = 'SQL exécuté avec succès'
feedback.pushInfo(msg)
else:
feedback.pushInfo('* ' + error_message)
raise QgsProcessingException(error_message)
return {
self.OUTPUT_STATUS: 0,
self.OUTPUT_STRING: msg
}
def checkParameterValues(self, parameters, context):
# Check if runit is checked
run_migration = self.parameterAsBool(parameters, self.RUN_MIGRATIONS,
context)
if not run_migration:
msg = 'Vous devez cocher cette case à cocher pour faire la mise à jour !'
ok = False
return ok, msg
# Check that the connection name has been configured
connection_name = QgsExpressionContextUtils.globalScope().variable(
'raepa_connection_name')
if not connection_name:
msg = (
'Vous devez utiliser l\'algorithme "Configuration du plugin RAEPA" pour paramètrer le nom de la '
'connexion.')
return False, msg
# Check that it corresponds to an existing connection
dbpluginclass = createDbPlugin('postgis')
connections = [c.connectionName() for c in dbpluginclass.connections()]
if connection_name not in connections:
msg = ('La connexion configurée "{}" n\'existe pas dans QGIS : {}'.
format(connection_name, ', '.join(connections)))
return False, msg
# Check database content
ok, msg = self.checkSchema(parameters, context)
if not ok:
return False, msg
return super(UpgradeDatabaseStructure,
self).checkParameterValues(parameters, context)
def initAlgorithm(self, config):
"""
Here we define the inputs and output of the algorithm, along
with some other properties.
"""
# INPUTS
# Database connection parameters
connection_name = QgsExpressionContextUtils.globalScope().variable('veloroutes_connection_name')
db_param = QgsProcessingParameterString(
self.CONNECTION_NAME,
'Connexion à la base PostgreSQL',
defaultValue=connection_name,
optional=False
)
db_param.setMetadata({
'widget_wrapper': {
'class': 'processing.gui.wrappers_postgis.ConnectionWidgetWrapper'
}
})
db_param.tooltip_3liz = 'Nom de la connexion dans QGIS pour se connecter à la base de données'
self.addParameter(db_param)
# OUTPUTS
# Add output for status (integer)
output = QgsProcessingOutputNumber(self.OUTPUT_STATUS, 'Statut de sortie')
output.tooltip_3liz = output.description()
self.addOutput(output)
# Add output for message
output = QgsProcessingOutputString(self.OUTPUT_STRING, 'Message de sortie')
output.tooltip_3liz = output.description()
self.addOutput(output)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
geometry_type = self.getParameterValue(self.OUTPUT_GEOMETRY)
wkb_type = None
if geometry_type == 0:
wkb_type = QgsWkbTypes.Polygon
elif geometry_type == 1:
wkb_type = QgsWkbTypes.LineString
else:
wkb_type = QgsWkbTypes.Point
if self.getParameterValue(self.WITH_Z):
wkb_type = QgsWkbTypes.addZ(wkb_type)
if self.getParameterValue(self.WITH_M):
wkb_type = QgsWkbTypes.addM(wkb_type)
writer = self.getOutputFromName(
self.OUTPUT_LAYER).getVectorWriter(
layer.fields(),
wkb_type,
layer.crs())
expression = QgsExpression(self.getParameterValue(self.EXPRESSION))
if expression.hasParserError():
raise GeoAlgorithmExecutionException(expression.parserErrorString())
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
if not expression.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % expression.evalErrorString()))
features = vector.features(layer)
total = 100.0 / len(features)
for current, input_feature in enumerate(features):
output_feature = input_feature
exp_context.setFeature(input_feature)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % expression.evalErrorString()))
if not value:
output_feature.setGeometry(QgsGeometry())
else:
if not isinstance(value, QgsGeometry):
raise GeoAlgorithmExecutionException(
self.tr('{} is not a geometry').format(value))
output_feature.setGeometry(value)
writer.addFeature(output_feature)
progress.setPercentage(int(current * total))
del writer
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
geometry_type = self.getParameterValue(self.OUTPUT_GEOMETRY)
wkb_type = None
if geometry_type == 0:
wkb_type = QgsWkbTypes.Polygon
elif geometry_type == 1:
wkb_type = QgsWkbTypes.LineString
else:
wkb_type = QgsWkbTypes.Point
if self.getParameterValue(self.WITH_Z):
wkb_type = QgsWkbTypes.addZ(wkb_type)
if self.getParameterValue(self.WITH_M):
wkb_type = QgsWkbTypes.addM(wkb_type)
writer = self.getOutputFromName(
self.OUTPUT_LAYER).getVectorWriter(
layer.fields(),
wkb_type,
layer.crs())
expression = QgsExpression(self.getParameterValue(self.EXPRESSION))
if expression.hasParserError():
raise GeoAlgorithmExecutionException(expression.parserErrorString())
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
if not expression.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % expression.evalErrorString()))
features = vector.features(layer)
total = 100.0 / len(features)
for current, input_feature in enumerate(features):
output_feature = input_feature
exp_context.setFeature(input_feature)
value = expression.evaluate(exp_context)
if expression.hasEvalError():
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % expression.evalErrorString()))
if not value:
output_feature.setGeometry(QgsGeometry())
else:
if not isinstance(value, QgsGeometry):
raise GeoAlgorithmExecutionException(
self.tr('{} is not a geometry').format(value))
output_feature.setGeometry(value)
writer.addFeature(output_feature)
progress.setPercentage(int(current * total))
del writer
def initContext(self):
exp_context = self.builder.expressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(self.layer))
exp_context.lastScope().setVariable("row_number", 1)
exp_context.setHighlightedVariables(["row_number"])
self.builder.setExpressionContext(exp_context)
def initAlgorithm(self, config):
# INPUTS
connection_name = QgsExpressionContextUtils.globalScope().variable(
'gobs_connection_name')
get_data = QgsExpressionContextUtils.globalScope().variable(
'gobs_get_database_data')
# List of spatial_layer
sql = '''
SELECT id, sl_label
FROM gobs.spatial_layer
ORDER BY sl_label
'''
dbpluginclass = createDbPlugin('postgis')
connections = [c.connectionName() for c in dbpluginclass.connections()]
data = []
if get_data == 'yes' and connection_name in connections:
[header, data, rowCount, ok,
error_message] = fetchDataFromSqlQuery(connection_name, sql)
self.SPATIALLAYERS = ['%s - %s' % (a[1], a[0]) for a in data]
self.addParameter(
QgsProcessingParameterEnum(self.SPATIALLAYER,
tr('Target spatial layer'),
options=self.SPATIALLAYERS,
optional=False))
self.addParameter(
QgsProcessingParameterVectorLayer(self.SOURCELAYER,
tr('Source data layer'),
optional=False))
self.addParameter(
QgsProcessingParameterField(
self.UNIQUEID,
tr('Unique identifier'),
parentLayerParameterName=self.SOURCELAYER))
self.addParameter(
QgsProcessingParameterField(
self.UNIQUELABEL,
tr('Unique label'),
parentLayerParameterName=self.SOURCELAYER,
type=QgsProcessingParameterField.String))
# OUTPUTS
# Add output for message
self.addOutput(
QgsProcessingOutputString(self.OUTPUT_STRING,
tr('Output message')))
def initContext(self):
exp_context = self.builder.expressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(
QgsExpressionContextUtils.layerScope(self.layer))
exp_context.lastScope().setVariable("row_number", 1)
exp_context.setHighlightedVariables(["row_number"])
self.builder.setExpressionContext(exp_context)
def expressionContext(self):
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope())
processingScope = QgsExpressionContextScope()
for param in self.alg.parameters:
processingScope.setVariable('%s_value' % param.name, '')
context.appendScope(processingScope)
return context
def _expressionContext(alg):
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope())
processingScope = QgsExpressionContextScope()
for param in alg.parameters:
processingScope.setVariable('%s_value' % param.name, '')
context.appendScope(processingScope)
return context
def expressionContext(self):
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope())
processingScope = QgsExpressionContextScope()
for param in self.alg.parameters:
processingScope.setVariable("%s_value" % param.name, "")
context.appendScope(processingScope)
return context
def initAlgorithm(self, config):
# use parent class to get other parameters
super(self.__class__, self).initAlgorithm(config)
connection_name = QgsExpressionContextUtils.globalScope().variable('gobs_connection_name')
get_data = QgsExpressionContextUtils.globalScope().variable('gobs_get_database_data')
# Add spatial layer choice
# List of spatial_layer
sql = '''
SELECT id, sl_label
FROM gobs.spatial_layer
ORDER BY sl_label
'''
dbpluginclass = createDbPlugin('postgis')
connections = [c.connectionName() for c in dbpluginclass.connections()]
data = []
if get_data == 'yes' and connection_name in connections:
[header, data, rowCount, ok, error_message] = fetchDataFromSqlQuery(
connection_name,
sql
)
self.SPATIALLAYERS = ['%s - %s' % (a[1], a[0]) for a in data]
self.SPATIALLAYERS_DICT = {a[0]: a[1] for a in data}
self.addParameter(
QgsProcessingParameterEnum(
self.SPATIALLAYER,
tr('Spatial layer'),
options=self.SPATIALLAYERS,
optional=False
)
)
# Id of spatial layer, to get the layer directly
# mainly used from other processing algs
p = QgsProcessingParameterNumber(
self.SPATIALLAYER_ID,
tr('Spatial layer ID. If given, it overrides previous choice'),
optional=True,
defaultValue=-1
)
p.setFlags(QgsProcessingParameterDefinition.FlagHidden)
self.addParameter(p)
def migrate_from_global_variables_to_pgmetadata_section():
""" Let's migrate from global variables to pgmetadata section in INI file. """
connection_names = QgsExpressionContextUtils.globalScope().variable(
"pgmetadata_connection_names")
if not connection_names:
return
QgsSettings().setValue("pgmetadata/connection_names", connection_names)
QgsExpressionContextUtils.removeGlobalVariable(
"pgmetadata_connection_names")
def initAlgorithm(self, config):
# use parent class to get other parameters
super(self.__class__, self).initAlgorithm(config)
project = QgsProject.instance()
connection_name = QgsExpressionContextUtils.projectScope(
project).variable('gobs_connection_name')
get_data = QgsExpressionContextUtils.globalScope().variable(
'gobs_get_database_data')
# List of series
sql = '''
SELECT s.id,
concat(
id_label,
' (', p.pr_label, ')',
' / Source: ', a_label,
' / Layer: ', sl_label
) AS label
FROM gobs.series s
INNER JOIN gobs.protocol p ON p.id = s.fk_id_protocol
INNER JOIN gobs.actor a ON a.id = s.fk_id_actor
INNER JOIN gobs.indicator i ON i.id = s.fk_id_indicator
INNER JOIN gobs.spatial_layer sl ON sl.id = s.fk_id_spatial_layer
ORDER BY label
'''
data = []
if get_data == 'yes' and connection_name in getPostgisConnectionList():
[header, data, rowCount, ok,
error_message] = fetchDataFromSqlQuery(connection_name, sql)
self.SERIES = ['%s' % a[1] for a in data]
self.SERIES_DICT = {a[1]: a[0] for a in data}
self.addParameter(
QgsProcessingParameterEnum(self.SERIE,
tr('Series of observations'),
options=self.SERIES,
optional=False))
# Id of series, to get the series directly
# mainly used from other processing algs
p = QgsProcessingParameterNumber(
self.SERIE_ID,
tr('Series ID. If given, it overrides previous choice'),
optional=True,
defaultValue=-1)
p.setFlags(QgsProcessingParameterDefinition.FlagHidden)
self.addParameter(p)
# Add spatial object geometry ?
self.addParameter(
QgsProcessingParameterBoolean(self.ADD_SPATIAL_OBJECT_GEOM,
tr('Add spatial object geometry ?'),
defaultValue=False,
optional=False))
def evaluateExpression(self, text):
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope())
exp = QgsExpression(text)
if exp.hasParserError():
raise Exception(exp.parserErrorString())
result = exp.evaluate(context)
if exp.hasEvalError():
raise ValueError(exp.evalErrorString())
return result
def get_qgis_variable(
name: str,
fallback_name: typing.Optional[str] = None) -> typing.Optional[str]:
global_scope = QgsExpressionContextUtils.globalScope()
value = global_scope.variable(name)
if value is not None:
result = value
elif fallback_name is not None:
result = global_scope.variable(fallback_name)
else:
result = value
return result
def processAlgorithm(self, parameters, context, feedback):
# parameters
connection_name = QgsExpressionContextUtils.globalScope().variable(
'gobs_connection_name')
delete_spatial_layer = self.parameterAsBool(parameters,
self.DELETE_SPATIAL_LAYER,
context)
# Get id, label and geometry type from chosen spatial layer
spatiallayer = self.SPATIALLAYERS[parameters[self.SPATIALLAYER]]
id_spatial_layer = int(spatiallayer.split('-')[-1].strip())
# Override spatial layer id from second number input
spatial_layer_id = self.parameterAsInt(parameters,
self.SPATIALLAYER_ID, context)
if spatial_layer_id and spatial_layer_id in self.SPATIALLAYERS_DICT:
id_spatial_layer = spatial_layer_id
sql = '''
DELETE FROM gobs.spatial_object
WHERE fk_id_spatial_layer = {0};
SELECT setval(
pg_get_serial_sequence('gobs.spatial_object', 'id'),
coalesce(max(id),0) + 1, false
) FROM gobs.spatial_object;
'''.format(id_spatial_layer)
if delete_spatial_layer:
sql += '''
DELETE FROM gobs.spatial_layer
WHERE id = {0};
SELECT setval(
pg_get_serial_sequence('gobs.spatial_layer', 'id'),
coalesce(max(id),0) + 1, false
) FROM gobs.spatial_layer;
'''.format(id_spatial_layer)
[header, data, rowCount, ok,
message] = fetchDataFromSqlQuery(connection_name, sql)
if ok:
message = tr(
'Spatial objects has been deleted for the chosen spatial layer'
)
if delete_spatial_layer:
message += '. ' + tr('The spatial layer has also been deleted')
feedback.pushInfo(message)
else:
raise QgsProcessingException(message)
status = 1
return {self.OUTPUT_STATUS: status, self.OUTPUT_STRING: message}
def doAction(self, layer, uid, feature):
if layer.actions().action(uid).name() == "openFeatureForm":
self.plugin.iface.openFeatureForm(layer, feature)
else:
ctxt = QgsExpressionContext()
ctxt.appendScope(QgsExpressionContextUtils.globalScope())
ctxt.appendScope(
QgsExpressionContextUtils.projectScope(QgsProject.instance()))
ctxt.appendScope(
QgsExpressionContextUtils.mapSettingsScope(
self.canvas.mapSettings()))
layer.actions().doAction(uid, feature, ctxt)
def initAlgorithm(self, config):
connection_name = QgsExpressionContextUtils.globalScope().variable(
"veloroutes_connection_name")
label = tr("Connexion PostgreSQL vers la base de données")
tooltip = 'Nom de la connexion dans QGIS pour se connecter à la base de données'
if Qgis.QGIS_VERSION_INT >= 31400:
param = QgsProcessingParameterProviderConnection(
self.CONNECTION_NAME,
label,
"postgres",
defaultValue=connection_name,
optional=False,
)
else:
param = QgsProcessingParameterString(
self.CONNECTION_NAME,
label,
defaultValue=connection_name,
optional=False,
)
param.setMetadata({
"widget_wrapper": {
"class":
"processing.gui.wrappers_postgis.ConnectionWidgetWrapper"
}
})
if Qgis.QGIS_VERSION_INT >= 31600:
param.setHelp(tooltip)
else:
param.tooltip_3liz = tooltip
self.addParameter(param)
self.addParameter(
QgsProcessingParameterBoolean(
self.OVERRIDE,
tr("Écraser le schéma {} ? ** ATTENTION ** "
"Cela supprimera toutes les données !").format(SCHEMA),
defaultValue=False,
optional=False,
))
self.addParameter(
QgsProcessingParameterBoolean(
self.ADD_TEST_DATA,
tr("Ajouter des données de test ?"),
defaultValue=False,
optional=False,
))
self.addOutput(
QgsProcessingOutputString(self.DATABASE_VERSION,
"Version de la base de données"))
def calculate( self, layer, fieldName, expression ):
if ( layer.featureCount() == 0 ):
self.msg.show( "[Info] * No existing features on layer " + layer.name() + " to calculate expression.", 'info', True )
return
expression = QgsExpression( expression )
if expression.hasParserError():
self.msg.show( QApplication.translate( "AutoFields-FieldCalculator", "[Error] (Parsing) " ) + \
expression.parserErrorString(), 'critical' )
return
context = QgsExpressionContext()
context.appendScope( QgsExpressionContextUtils.globalScope() )
context.appendScope( QgsExpressionContextUtils.projectScope() )
context.appendScope( QgsExpressionContextUtils.layerScope( layer ) )
context.setFields( layer.fields() )
if expression.needsGeometry():
if self.iface:
# This block was borrowed from QGIS/python/plugins/processing/algs/qgis/FieldsCalculator.py
da = QgsDistanceArea()
da.setSourceCrs( layer.crs().srsid() )
da.setEllipsoidalMode( self.iface.mapCanvas().mapSettings().hasCrsTransformEnabled() )
da.setEllipsoid( QgsProject.instance().readEntry( 'Measure', '/Ellipsoid', GEO_NONE )[0] )
expression.setGeomCalculator( da )
if QGis.QGIS_VERSION_INT >= 21400: # Methods added in QGIS 2.14
expression.setDistanceUnits( QgsProject.instance().distanceUnits() )
expression.setAreaUnits( QgsProject.instance().areaUnits() )
expression.prepare( context )
fieldIndex = layer.fieldNameIndex( fieldName )
if fieldIndex == -1:
return
field = layer.fields()[fieldIndex]
dictResults = {}
for feature in layer.getFeatures():
context.setFeature( feature )
result = expression.evaluate( context )
if expression.hasEvalError():
self.msg.show( QApplication.translate( "AutoFields-FieldCalculator", "[Error] (Evaluating) " ) + \
expression.evalErrorString(), 'critical' )
return
dictResults[feature.id()] = { fieldIndex: field.convertCompatible( result ) }
layer.dataProvider().changeAttributeValues( dictResults )
self.msg.show( "[Info] * An expression was calculated on existing features of layer " + layer.name() + ", field " + fieldName + ".", 'info', True )
def __init__(self, provider):
super(PyFeatureSource, self).__init__()
self._provider = provider
self._features = provider._features
self._expression_context = QgsExpressionContext()
self._expression_context.appendScope(QgsExpressionContextUtils.globalScope())
self._expression_context.appendScope(QgsExpressionContextUtils.projectScope(QgsProject.instance()))
self._expression_context.setFields(self._provider.fields())
if self._provider.subsetString():
self._subset_expression = QgsExpression(self._provider.subsetString())
self._subset_expression.prepare(self._expression_context)
else:
self._subset_expression = None
def updateLayer(self):
self.layer = dataobjects.getObject(self.cmbInputLayer.currentText())
self.builder.setLayer(self.layer)
self.builder.loadFieldNames()
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(
QgsExpressionContextUtils.layerScope(self.layer))
exp_context.lastScope().setVariable("row_number", 1)
exp_context.setHighlightedVariables(["row_number"])
self.builder.setExpressionContext(exp_context)
self.populateFields()
