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()