Port another alg to new API

python/plugins/processing/algs/qgis/AddTableField.py

@@ -29,13 +29,14 @@ from qgis.PyQt.QtCore import QVariant
 from qgis.core import (QgsField,
                        QgsFeature,
                        QgsApplication,
-                       QgsProcessingUtils)
+                       QgsProcessingUtils,
-from processing.algs.qgis import QgisAlgorithm
+                       QgsProcessingParameterFeatureSource,
-from processing.core.parameters import ParameterVector
+                       QgsProcessingParameterString,
-from processing.core.parameters import ParameterString
+                       QgsProcessingParameterNumber,
-from processing.core.parameters import ParameterNumber
+                       QgsProcessingParameterEnum,
-from processing.core.parameters import ParameterSelection
+                       QgsProcessingParameterFeatureSink,
-from processing.core.outputs import OutputVector
+                       QgsProcessingOutputVectorLayer)
+from processing.algs.qgis.QgisAlgorithm import QgisAlgorithm
 
 
 class AddTableField(QgisAlgorithm):
@@ -64,18 +65,19 @@ class AddTableField(QgisAlgorithm):
                            self.tr('Float'),
                            self.tr('String')]
 
-        self.addParameter(ParameterVector(self.INPUT_LAYER,
+        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT_LAYER,
-                                          self.tr('Input layer')))
+                                                              self.tr('Input layer')))
-        self.addParameter(ParameterString(self.FIELD_NAME,
+        self.addParameter(QgsProcessingParameterString(self.FIELD_NAME,
-                                          self.tr('Field name')))
+                                                       self.tr('Field name')))
-        self.addParameter(ParameterSelection(self.FIELD_TYPE,
+        self.addParameter(QgsProcessingParameterEnum(self.FIELD_TYPE,
-                                             self.tr('Field type'), self.type_names))
+                                                     self.tr('Field type'), self.type_names))
-        self.addParameter(ParameterNumber(self.FIELD_LENGTH,
+        self.addParameter(QgsProcessingParameterNumber(self.FIELD_LENGTH,
-                                          self.tr('Field length'), 1, 255, 10))
+                                                       self.tr('Field length'), QgsProcessingParameterNumber.Integer,
-        self.addParameter(ParameterNumber(self.FIELD_PRECISION,
+                                                       10, False, 1, 255))
-                                          self.tr('Field precision'), 0, 10, 0))
+        self.addParameter(QgsProcessingParameterNumber(self.FIELD_PRECISION,
-        self.addOutput(OutputVector(
+                                                       self.tr('Field precision'), QgsProcessingParameterNumber.Integer, 0, False, 0, 10))
-            self.OUTPUT_LAYER, self.tr('Added')))
+        self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT_LAYER, self.tr('Added')))
+        self.addOutput(QgsProcessingOutputVectorLayer(self.OUTPUT_LAYER, self.tr('Added')))
 
     def name(self):
         return 'addfieldtoattributestable'
@@ -84,27 +86,32 @@ class AddTableField(QgisAlgorithm):
         return self.tr('Add field to attributes table')
 
     def processAlgorithm(self, parameters, context, feedback):
-        fieldType = self.getParameterValue(self.FIELD_TYPE)
+        source = self.parameterAsSource(parameters, self.INPUT_LAYER, context)
-        fieldName = self.getParameterValue(self.FIELD_NAME)
-        fieldLength = self.getParameterValue(self.FIELD_LENGTH)
-        fieldPrecision = self.getParameterValue(self.FIELD_PRECISION)
-        output = self.getOutputFromName(self.OUTPUT_LAYER)
 
-        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)
+        fieldType = self.parameterAsEnum(parameters, self.FIELD_TYPE, context)
+        fieldName = self.parameterAsString(parameters, self.FIELD_NAME, context)
+        fieldLength = self.parameterAsInt(parameters, self.FIELD_LENGTH, context)
+        fieldPrecision = self.parameterAsInt(parameters, self.FIELD_PRECISION, context)
 
-        fields = layer.fields()
+        fields = source.fields()
         fields.append(QgsField(fieldName, self.TYPES[fieldType], '',
                                fieldLength, fieldPrecision))
-        writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
+        (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT_LAYER, context,
-        outFeat = QgsFeature()
+                                               fields, source.wkbType(), source.sourceCrs())
-        features = QgsProcessingUtils.getFeatures(layer, context)
+
-        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
+        features = source.getFeatures()
-        for current, feat in enumerate(features):
+        total = 100.0 / source.featureCount()
+
+        for current, input_feature in enumerate(features):
+            if feedback.isCanceled():
+                break
+
+            output_feature = input_feature
+            attributes = input_feature.attributes()
+            attributes.append(None)
+            output_feature.setAttributes(attributes)
+
+            sink.addFeature(output_feature)
             feedback.setProgress(int(current * total))
-            geom = feat.geometry()
+
-            outFeat.setGeometry(geom)
+        return {self.OUTPUT_LAYER: dest_id}
-            atMap = feat.attributes()
-            atMap.append(None)
-            outFeat.setAttributes(atMap)
-            writer.addFeature(outFeat)
-        del writer

python/plugins/processing/algs/qgis/QGISAlgorithmProvider.py

@@ -104,7 +104,7 @@ from .QgisAlgorithm import QgisAlgorithm
 # from .RasterLayerStatistics import RasterLayerStatistics
 # from .StatisticsByCategories import StatisticsByCategories
 # from .EquivalentNumField import EquivalentNumField
-# from .AddTableField import AddTableField
+from .AddTableField import AddTableField
 # from .FieldsCalculator import FieldsCalculator
 # from .SaveSelectedFeatures import SaveSelectedFeatures
 # from .Explode import Explode
@@ -220,7 +220,7 @@ class QGISAlgorithmProvider(QgsProcessingProvider):
         #         ExtractByAttribute(), SelectByAttribute(), GridPolygon(),
         #         GridLine(), Gridify(), HubDistancePoints(),
         #         HubDistanceLines(), HubLines(), Merge(),
-        #         GeometryConvert(), AddTableField(), FieldsCalculator(),
+        #         GeometryConvert(), FieldsCalculator(),
         #         SaveSelectedFeatures(), JoinAttributes(),
         #         AutoincrementalField(), Explode(), FieldsPyculator(),
         #         EquivalentNumField(), PointsLayerFromTable(),
@@ -259,7 +259,8 @@ class QGISAlgorithmProvider(QgsProcessingProvider):
         #         FixGeometry(), ExecuteSQL(), FindProjection(),
         #         TopoColor(), EliminateSelection()
         #         ]
-        algs = [Boundary(),
+        algs = [AddTableField(),
+                Boundary(),
                 BoundingBox()]
 
         # if hasPlotly:

python/plugins/processing/gui/wrappers.py

@@ -909,6 +909,21 @@ class StringWidgetWrapper(WidgetWrapper, ExpressionWidgetWrapperMixin):
                     widget.addItem(desc, val)
         return widget
 
+    def showExpressionsBuilder(self):
+        context = dataobjects.createExpressionContext()
+        value = self.value()
+        if not isinstance(value, str):
+            value = ''
+        dlg = QgsExpressionBuilderDialog(None, value, self.widget, 'generic', context)
+        dlg.setWindowTitle(self.tr('Expression based input'))
+        if dlg.exec_() == QDialog.Accepted:
+            exp = QgsExpression(dlg.expressionText())
+            if not exp.hasParserError():
+                if self.dialogType == DIALOG_STANDARD:
+                    self.setValue(str(exp.evaluate(context)))
+                else:
+                    self.setValue(dlg.expressionText())
+
     def setValue(self, value):
         if self.dialogType == DIALOG_STANDARD:
             if self.param.multiLine():

python/plugins/processing/tests/testdata/qgis_algorithm_tests.yaml

@@ -2524,21 +2524,21 @@ tests:
 #  #       name: expected/extract_by_location_within.gml
 #  #       type: vector
 #
-#  - algorithm: qgis:addfieldtoattributestable
+  - algorithm: qgis:addfieldtoattributestable
-#    name: add float field
+    name: add float field
-#    params:
+    params:
-#      FIELD_LENGTH: 10
+      FIELD_LENGTH: 10
-#      FIELD_NAME: field
+      FIELD_NAME: field
-#      FIELD_PRECISION: 2
+      FIELD_PRECISION: 2
-#      FIELD_TYPE: '1'
+      FIELD_TYPE: '1'
-#      INPUT_LAYER:
+      INPUT_LAYER:
-#        name: custom/points.shp
+        name: custom/points.shp
-#        type: vector
+        type: vector
-#    results:
+    results:
-#      OUTPUT_LAYER:
+      OUTPUT_LAYER:
-#        name: expected/add_field.gml
+        name: expected/add_field.gml
-#        type: vector
+        type: vector
-#
+
 #  - algorithm: qgis:randompointsinextent
 #    name: Random point in extent, don't check result
 #    params: