bool QgsMemoryProvider::changeAttributeValues( const QgsChangedAttributesMap & attr_map )
{
for ( QgsChangedAttributesMap::const_iterator it = attr_map.begin(); it != attr_map.end(); ++it )
{
QgsFeatureMap::iterator fit = mFeatures.find( it.key() );
if ( fit == mFeatures.end() )
continue;
const QgsAttributeMap& attrs = it.value();
for ( QgsAttributeMap::const_iterator it2 = attrs.begin(); it2 != attrs.end(); ++it2 )
fit->changeAttribute( it2.key(), it2.value() );
}
return TRUE;
}
QgsVectorLayerUndoCommandDeleteAttribute::QgsVectorLayerUndoCommandDeleteAttribute( QgsVectorLayerEditBuffer* buffer, int fieldIndex )
: QgsVectorLayerUndoCommand( buffer )
, mFieldIndex( fieldIndex )
{
const QgsFields& fields = layer()->fields();
QgsFields::FieldOrigin origin = fields.fieldOrigin( mFieldIndex );
mOriginIndex = fields.fieldOriginIndex( mFieldIndex );
mProviderField = ( origin == QgsFields::OriginProvider );
mFieldName = fields.field( mFieldIndex ).name();
mOldEditorWidgetConfig = mBuffer->L->editFormConfig().widgetConfig( mFieldName );
if ( !mProviderField )
{
// need to store the field definition
mOldField = mBuffer->mAddedAttributes[mOriginIndex];
}
if ( mBuffer->mRenamedAttributes.contains( fieldIndex ) )
{
mOldName = mBuffer->mRenamedAttributes.value( fieldIndex );
}
// save values of new features
for ( QgsFeatureMap::const_iterator it = mBuffer->mAddedFeatures.constBegin(); it != mBuffer->mAddedFeatures.constEnd(); ++it )
{
const QgsFeature& f = it.value();
mDeletedValues.insert( f.id(), f.attribute( mFieldIndex ) );
}
// save changed values
for ( QgsChangedAttributesMap::const_iterator it = mBuffer->mChangedAttributeValues.constBegin(); it != mBuffer->mChangedAttributeValues.constEnd(); ++it )
{
const QgsAttributeMap& attrs = it.value();
if ( attrs.contains( mFieldIndex ) )
mDeletedValues.insert( it.key(), attrs[mFieldIndex] );
}
}
void QgsOfflineEditing::committedAttributeValuesChanges( const QString& qgisLayerId, const QgsChangedAttributesMap& changedAttrsMap )
{
sqlite3* db = openLoggingDb();
if ( db == NULL )
{
return;
}
// insert log
int layerId = getOrCreateLayerId( db, qgisLayerId );
int commitNo = getCommitNo( db );
for ( QgsChangedAttributesMap::const_iterator cit = changedAttrsMap.begin(); cit != changedAttrsMap.end(); ++cit )
{
QgsFeatureId fid = cit.key();
if ( isAddedFeature( db, layerId, fid ) )
{
// skip added features
continue;
}
QgsAttributeMap attrMap = cit.value();
for ( QgsAttributeMap::const_iterator it = attrMap.begin(); it != attrMap.end(); ++it )
{
QString sql = QString( "INSERT INTO 'log_feature_updates' VALUES ( %1, %2, %3, %4, '%5' )" )
.arg( layerId )
.arg( commitNo )
.arg( fid )
.arg( it.key() ) // attr
.arg( it.value().toString() ); // value
sqlExec( db, sql );
}
}
increaseCommitNo( db );
sqlite3_close( db );
}
bool QgsGPXProvider::changeAttributeValues( const QgsChangedAttributesMap &attr_map )
{
QgsChangedAttributesMap::const_iterator aIter = attr_map.begin();
if ( mFeatureType == WaypointType )
{
QgsGPSData::WaypointIterator wIter = data->waypointsBegin();
for ( ; wIter != data->waypointsEnd() && aIter != attr_map.end(); ++wIter )
{
if ( wIter->id == aIter.key() )
{
changeAttributeValues( *wIter, aIter.value() );
++aIter;
}
}
}
else if ( mFeatureType == RouteType )
{
QgsGPSData::RouteIterator rIter = data->routesBegin();
for ( ; rIter != data->routesEnd() && aIter != attr_map.end(); ++rIter )
{
if ( rIter->id == aIter.key() )
{
changeAttributeValues( *rIter, aIter.value() );
++aIter;
}
}
}
if ( mFeatureType == TrackType )
{
QgsGPSData::TrackIterator tIter = data->tracksBegin();
for ( ; tIter != data->tracksEnd() && aIter != attr_map.end(); ++tIter )
{
if ( tIter->id == aIter.key() )
{
changeAttributeValues( *tIter, aIter.value() );
++aIter;
}
}
}
// write back to file
QFile file( mFileName );
if ( !file.open( QIODevice::WriteOnly ) )
return false;
QTextStream ostr( &file );
data->writeXML( ostr );
return true;
}
bool QgsWFSProvider::changeAttributeValues( const QgsChangedAttributesMap &attr_map )
{
//find out typename from uri and strip namespace prefix
QString tname = mShared->mURI.typeName();
if ( tname.isNull() )
{
return false;
}
//create <Transaction> xml
QDomDocument transactionDoc;
QDomElement transactionElem = createTransactionElement( transactionDoc );
transactionDoc.appendChild( transactionElem );
QgsChangedAttributesMap::const_iterator attIt = attr_map.constBegin();
for ( ; attIt != attr_map.constEnd(); ++attIt )
{
QString gmlid = mShared->findGmlId( attIt.key() );
if ( gmlid.isEmpty() )
{
QgsDebugMsg( QString( "Cannot identify feature of id %1" ).arg( attIt.key() ) );
continue;
}
QDomElement updateElem = transactionDoc.createElementNS( QgsWFSConstants::WFS_NAMESPACE, "Update" );
updateElem.setAttribute( "typeName", tname );
QgsAttributeMap::const_iterator attMapIt = attIt.value().constBegin();
for ( ; attMapIt != attIt.value().constEnd(); ++attMapIt )
{
QString fieldName = mShared->mFields.at( attMapIt.key() ).name();
QDomElement propertyElem = transactionDoc.createElementNS( QgsWFSConstants::WFS_NAMESPACE, "Property" );
QDomElement nameElem = transactionDoc.createElementNS( QgsWFSConstants::WFS_NAMESPACE, "Name" );
QDomText nameText = transactionDoc.createTextNode( fieldName );
nameElem.appendChild( nameText );
propertyElem.appendChild( nameElem );
QDomElement valueElem = transactionDoc.createElementNS( QgsWFSConstants::WFS_NAMESPACE, "Value" );
QDomText valueText = transactionDoc.createTextNode( attMapIt.value().toString() );
valueElem.appendChild( valueText );
propertyElem.appendChild( valueElem );
updateElem.appendChild( propertyElem );
}
//Filter
QDomElement filterElem = transactionDoc.createElementNS( QgsWFSConstants::OGC_NAMESPACE, "Filter" );
QDomElement featureIdElem = transactionDoc.createElementNS( QgsWFSConstants::OGC_NAMESPACE, "FeatureId" );
featureIdElem.setAttribute( "fid", gmlid );
filterElem.appendChild( featureIdElem );
updateElem.appendChild( filterElem );
transactionElem.appendChild( updateElem );
}
QDomDocument serverResponse;
bool success = sendTransactionDocument( transactionDoc, serverResponse );
if ( !success )
{
return false;
}
if ( transactionSuccess( serverResponse ) )
{
mShared->changeAttributeValues( attr_map );
return true;
}
else
{
handleException( serverResponse );
return false;
}
}
bool QgsDb2Provider::changeAttributeValues( const QgsChangedAttributesMap &attr_map )
{
QgsDebugMsg( "Entering" );
if ( attr_map.isEmpty() )
return true;
if ( mFidColName.isEmpty() )
return false;
for ( QgsChangedAttributesMap::const_iterator it = attr_map.begin(); it != attr_map.end(); ++it )
{
QgsFeatureId fid = it.key();
// skip added features
if ( FID_IS_NEW( fid ) )
continue;
const QgsAttributeMap& attrs = it.value();
if ( attrs.isEmpty() )
continue;
QString statement = QString( "UPDATE %1.%2 SET " ).arg( mSchemaName, mTableName );
bool first = true;
if ( !mDatabase.isOpen() )
{
QString errMsg;
mDatabase = getDatabase( mConnInfo, errMsg );
if ( !errMsg.isEmpty() )
{
return false;
}
}
QSqlQuery query = QSqlQuery( mDatabase );
query.setForwardOnly( true );
for ( QgsAttributeMap::const_iterator it2 = attrs.begin(); it2 != attrs.end(); ++it2 )
{
QgsField fld = mAttributeFields.at( it2.key() );
if ( fld.typeName().endsWith( " identity", Qt::CaseInsensitive ) )
continue; // skip identity field
if ( fld.name().isEmpty() )
continue; // invalid
if ( !first )
statement += ',';
else
first = false;
statement += QString( "%1=?" ).arg( fld.name() );
}
if ( first )
return true; // no fields have been changed
// set attribute filter
statement += QString( " WHERE %1=%2" ).arg( mFidColName, FID_TO_STRING( fid ) );
// use prepared statement to prevent from sql injection
if ( !query.prepare( statement ) )
{
QgsDebugMsg( query.lastError().text() );
return false;
}
QgsDebugMsg( statement );
for ( QgsAttributeMap::const_iterator it2 = attrs.begin(); it2 != attrs.end(); ++it2 )
{
QgsField fld = mAttributeFields.at( it2.key() );
if ( fld.name().isEmpty() )
continue; // invalid
QVariant::Type type = fld.type();
if ( it2->isNull() || !it2->isValid() )
{
// binding null values
if ( type == QVariant::Date || type == QVariant::DateTime )
query.addBindValue( QVariant( QVariant::String ) );
else
query.addBindValue( QVariant( type ) );
}
else if ( type == QVariant::Int )
{
// binding an INTEGER value
query.addBindValue( it2->toInt() );
}
else if ( type == QVariant::Double )
{
// binding a DOUBLE value
query.addBindValue( it2->toDouble() );
}
else if ( type == QVariant::String )
{
// binding a TEXT value
query.addBindValue( it2->toString() );
}
else if ( type == QVariant::DateTime )
{
// binding a DATETIME value
query.addBindValue( it2->toDateTime().toString( Qt::ISODate ) );
}
else if ( type == QVariant::Date )
{
// binding a DATE value
query.addBindValue( it2->toDate().toString( Qt::ISODate ) );
}
else if ( type == QVariant::Time )
{
// binding a TIME value
query.addBindValue( it2->toTime().toString( Qt::ISODate ) );
}
else
{
query.addBindValue( *it2 );
}
}
if ( !query.exec() )
{
QgsDebugMsg( query.lastError().text() );
return false;
}
}
return true;
}
