Branch data     Line data    Source code

       1                 :            : /***************************************************************************
       2                 :            :                          qgsalgorithmaddincrementalfield.cpp
       3                 :            :                          -----------------------------------
       4                 :            :     begin                : April 2017
       5                 :            :     copyright            : (C) 2017 by Nyall Dawson
       6                 :            :     email                : nyall dot dawson at gmail dot com
       7                 :            :  ***************************************************************************/
       8                 :            : 
       9                 :            : /***************************************************************************
      10                 :            :  *                                                                         *
      11                 :            :  *   This program is free software; you can redistribute it and/or modify  *
      12                 :            :  *   it under the terms of the GNU General Public License as published by  *
      13                 :            :  *   the Free Software Foundation; either version 2 of the License, or     *
      14                 :            :  *   (at your option) any later version.                                   *
      15                 :            :  *                                                                         *
      16                 :            :  ***************************************************************************/
      17                 :            : 
      18                 :            : #include "qgsalgorithmaddincrementalfield.h"
      19                 :            : #include "qgsfeaturerequest.h"
      20                 :            : 
      21                 :            : ///@cond PRIVATE
      22                 :            : 
      23                 :          0 : QString QgsAddIncrementalFieldAlgorithm::name() const
      24                 :            : {
      25                 :          0 :   return QStringLiteral( "addautoincrementalfield" );
      26                 :            : }
      27                 :            : 
      28                 :          0 : QString QgsAddIncrementalFieldAlgorithm::displayName() const
      29                 :            : {
      30                 :          0 :   return QObject::tr( "Add autoincremental field" );
      31                 :            : }
      32                 :            : 
      33                 :          0 : QString QgsAddIncrementalFieldAlgorithm::shortHelpString() const
      34                 :            : {
      35                 :          0 :   return QObject::tr( "This algorithm adds a new integer field to a vector layer, with a sequential value for each feature.\n\n"
      36                 :            :                       "This field can be used as a unique ID for features in the layer. The new attribute "
      37                 :            :                       "is not added to the input layer but a new layer is generated instead.\n\n"
      38                 :            :                       "The initial starting value for the incremental series can be specified.\n\n"
      39                 :            :                       "Optionally, grouping fields can be specified. If group fields are present, then the field value will "
      40                 :            :                       "be reset for each combination of these group field values.\n\n"
      41                 :            :                       "The sort order for features may be specified, if so, then the incremental field will respect "
      42                 :            :                       "this sort order." );
      43                 :            : }
      44                 :            : 
      45                 :          0 : QStringList QgsAddIncrementalFieldAlgorithm::tags() const
      46                 :            : {
      47                 :          0 :   return QObject::tr( "add,create,serial,primary,key,unique,fields" ).split( ',' );
      48                 :          0 : }
      49                 :            : 
      50                 :          0 : QString QgsAddIncrementalFieldAlgorithm::group() const
      51                 :            : {
      52                 :          0 :   return QObject::tr( "Vector table" );
      53                 :            : }
      54                 :            : 
      55                 :          0 : QString QgsAddIncrementalFieldAlgorithm::groupId() const
      56                 :            : {
      57                 :          0 :   return QStringLiteral( "vectortable" );
      58                 :            : }
      59                 :            : 
      60                 :          0 : QString QgsAddIncrementalFieldAlgorithm::outputName() const
      61                 :            : {
      62                 :          0 :   return QObject::tr( "Incremented" );
      63                 :            : }
      64                 :            : 
      65                 :          0 : QList<int> QgsAddIncrementalFieldAlgorithm::inputLayerTypes() const
      66                 :            : {
      67                 :          0 :   return QList<int>() << QgsProcessing::TypeVector;
      68                 :          0 : }
      69                 :            : 
      70                 :          0 : QgsAddIncrementalFieldAlgorithm *QgsAddIncrementalFieldAlgorithm::createInstance() const
      71                 :            : {
      72                 :          0 :   return new QgsAddIncrementalFieldAlgorithm();
      73                 :          0 : }
      74                 :            : 
      75                 :          0 : QgsProcessingFeatureSource::Flag QgsAddIncrementalFieldAlgorithm::sourceFlags() const
      76                 :            : {
      77                 :          0 :   return QgsProcessingFeatureSource::FlagSkipGeometryValidityChecks;
      78                 :            : }
      79                 :            : 
      80                 :          0 : void QgsAddIncrementalFieldAlgorithm::initParameters( const QVariantMap & )
      81                 :            : {
      82                 :          0 :   addParameter( new QgsProcessingParameterString( QStringLiteral( "FIELD_NAME" ), QObject::tr( "Field name" ), QStringLiteral( "AUTO" ) ) );
      83                 :          0 :   addParameter( new QgsProcessingParameterNumber( QStringLiteral( "START" ), QObject::tr( "Start values at" ),
      84                 :          0 :                 QgsProcessingParameterNumber::Integer, 0, true ) );
      85                 :          0 :   addParameter( new QgsProcessingParameterField( QStringLiteral( "GROUP_FIELDS" ), QObject::tr( "Group values by" ), QVariant(),
      86                 :          0 :                 QStringLiteral( "INPUT" ), QgsProcessingParameterField::Any, true, true ) );
      87                 :            : 
      88                 :            :   // sort params
      89                 :          0 :   std::unique_ptr< QgsProcessingParameterExpression > sortExp = std::make_unique< QgsProcessingParameterExpression >( QStringLiteral( "SORT_EXPRESSION" ), QObject::tr( "Sort expression" ), QVariant(), QStringLiteral( "INPUT" ), true );
      90                 :          0 :   sortExp->setFlags( sortExp->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
      91                 :          0 :   addParameter( sortExp.release() );
      92                 :          0 :   std::unique_ptr< QgsProcessingParameterBoolean > sortAscending = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "SORT_ASCENDING" ), QObject::tr( "Sort ascending" ), true );
      93                 :          0 :   sortAscending->setFlags( sortAscending->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
      94                 :          0 :   addParameter( sortAscending.release() );
      95                 :          0 :   std::unique_ptr< QgsProcessingParameterBoolean > sortNullsFirst = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "SORT_NULLS_FIRST" ), QObject::tr( "Sort nulls first" ), false );
      96                 :          0 :   sortNullsFirst->setFlags( sortNullsFirst->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
      97                 :          0 :   addParameter( sortNullsFirst.release() );
      98                 :          0 : }
      99                 :            : 
     100                 :          0 : QgsFields QgsAddIncrementalFieldAlgorithm::outputFields( const QgsFields &inputFields ) const
     101                 :            : {
     102                 :          0 :   QgsFields outFields = inputFields;
     103                 :          0 :   outFields.append( QgsField( mFieldName, QVariant::LongLong ) );
     104                 :          0 :   mFields = outFields;
     105                 :          0 :   return outFields;
     106                 :          0 : }
     107                 :            : 
     108                 :          0 : bool QgsAddIncrementalFieldAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
     109                 :            : {
     110                 :          0 :   mStartValue = parameterAsInt( parameters, QStringLiteral( "START" ), context );
     111                 :          0 :   mValue = mStartValue;
     112                 :          0 :   mFieldName = parameterAsString( parameters, QStringLiteral( "FIELD_NAME" ), context );
     113                 :          0 :   mGroupedFieldNames = parameterAsFields( parameters, QStringLiteral( "GROUP_FIELDS" ), context );
     114                 :            : 
     115                 :          0 :   mSortExpressionString = parameterAsExpression( parameters, QStringLiteral( "SORT_EXPRESSION" ), context );
     116                 :          0 :   mSortAscending = parameterAsBoolean( parameters, QStringLiteral( "SORT_ASCENDING" ), context );
     117                 :          0 :   mSortNullsFirst = parameterAsBoolean( parameters, QStringLiteral( "SORT_NULLS_FIRST" ), context );
     118                 :            : 
     119                 :          0 :   return true;
     120                 :          0 : }
     121                 :            : 
     122                 :          0 : QgsFeatureRequest QgsAddIncrementalFieldAlgorithm::request() const
     123                 :            : {
     124                 :          0 :   if ( mSortExpressionString.isEmpty() )
     125                 :          0 :     return QgsFeatureRequest();
     126                 :            : 
     127                 :          0 :   return QgsFeatureRequest().setOrderBy( QgsFeatureRequest::OrderBy() << QgsFeatureRequest::OrderByClause( mSortExpressionString, mSortAscending, mSortNullsFirst ) );
     128                 :          0 : }
     129                 :            : 
     130                 :          0 : QgsFeatureList QgsAddIncrementalFieldAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback * )
     131                 :            : {
     132                 :          0 :   if ( !mGroupedFieldNames.empty() && mGroupedFields.empty() )
     133                 :            :   {
     134                 :          0 :     for ( const QString &field : std::as_const( mGroupedFieldNames ) )
     135                 :            :     {
     136                 :          0 :       int idx = mFields.lookupField( field );
     137                 :          0 :       if ( idx >= 0 )
     138                 :          0 :         mGroupedFields << idx;
     139                 :            :     }
     140                 :          0 :   }
     141                 :            : 
     142                 :          0 :   QgsFeature f = feature;
     143                 :          0 :   QgsAttributes attributes = f.attributes();
     144                 :          0 :   if ( mGroupedFields.empty() )
     145                 :            :   {
     146                 :          0 :     attributes.append( mValue );
     147                 :          0 :     mValue++;
     148                 :          0 :   }
     149                 :            :   else
     150                 :            :   {
     151                 :          0 :     QgsAttributes groupAttributes;
     152                 :          0 :     groupAttributes.reserve( mGroupedFields.size() );
     153                 :          0 :     for ( int index : std::as_const( mGroupedFields ) )
     154                 :            :     {
     155                 :          0 :       groupAttributes << f.attribute( index );
     156                 :            :     }
     157                 :          0 :     long long value = mGroupedValues.value( groupAttributes, mStartValue );
     158                 :          0 :     attributes.append( value );
     159                 :          0 :     value++;
     160                 :          0 :     mGroupedValues[ groupAttributes ] = value;
     161                 :          0 :   }
     162                 :          0 :   f.setAttributes( attributes );
     163                 :          0 :   return QgsFeatureList() << f;
     164                 :          0 : }
     165                 :            : 
     166                 :          0 : bool QgsAddIncrementalFieldAlgorithm::supportInPlaceEdit( const QgsMapLayer *layer ) const
     167                 :            : {
     168                 :            :   Q_UNUSED( layer )
     169                 :          0 :   return false;
     170                 :            : }
     171                 :            : 
     172                 :            : ///@endcond