QGIS API Documentation 3.30.0-'s-Hertogenbosch (f186b8efe0)
qgsweakrelation.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsweakrelation.cpp - QgsWeakRelation
3
4 ---------------------
5 begin : 5.12.2019
6 copyright : (C) 2019 by Alessandro Pasotti
7 email : elpaso at itopen dot it
8 ***************************************************************************
9 * *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 ***************************************************************************/
16
17#include <QApplication>
18#include "qgsweakrelation.h"
19#include "qgslogger.h"
20#include "qgsproviderregistry.h"
21#include "qgsprovidermetadata.h"
22
24
25QgsWeakRelation::QgsWeakRelation( const QString &relationId, const QString &relationName, const Qgis::RelationshipStrength strength,
26 const QString &referencingLayerId, const QString &referencingLayerName, const QString &referencingLayerSource, const QString &referencingLayerProviderKey,
27 const QString &referencedLayerId, const QString &referencedLayerName, const QString &referencedLayerSource, const QString &referencedLayerProviderKey )
28 : mReferencingLayer( referencingLayerId, referencingLayerName, referencingLayerSource, referencingLayerProviderKey )
29 , mReferencedLayer( referencedLayerId, referencedLayerName, referencedLayerSource, referencedLayerProviderKey )
30 , mRelationId( relationId )
31 , mRelationName( relationName )
32 , mStrength( strength )
33{
34}
35
36QList< QgsRelation > QgsWeakRelation::resolvedRelations( const QgsProject *project, QgsVectorLayerRef::MatchType matchType ) const
37{
38 QList< QgsRelation > res;
39
40 switch ( mCardinality )
41 {
45 {
46
47 QgsRelation relation;
48 relation.setId( mRelationId );
49 relation.setName( mRelationName );
50 relation.setStrength( mStrength );
51 QgsVectorLayerRef referencedLayerRef = mReferencedLayer;
52 QgsMapLayer *referencedLayer = referencedLayerRef.resolveWeakly( project, matchType );
53 if ( referencedLayer )
54 {
56 }
57 QgsVectorLayerRef referencingLayerRef = mReferencingLayer;
58 QgsMapLayer *referencingLayer = referencingLayerRef.resolveWeakly( project, matchType );
59 if ( referencingLayer )
60 {
62 }
63
64 for ( int i = 0 ; i < std::min( mReferencingLayerFields.size(), mReferencedLayerFields.size() ); ++i )
65 {
66 relation.addFieldPair( mReferencingLayerFields.at( i ), mReferencedLayerFields.at( i ) );
67 }
68
69 res.push_back( relation );
70 break;
71 }
72
74 {
75 // a many-to-many relationship is represented by two QgsRelations
76 QgsRelation relationLeft;
77 relationLeft.setId( mRelationId + QStringLiteral( "_forward" ) );
78 relationLeft.setName( mRelationName + QStringLiteral( "_forward" ) );
79 relationLeft.setStrength( mStrength );
80 QgsVectorLayerRef referencedLayerRef = mReferencedLayer;
81 QgsMapLayer *referencedLayer = referencedLayerRef.resolveWeakly( project, matchType );
82 if ( referencedLayer )
83 {
84 relationLeft.setReferencedLayer( referencedLayer->id() );
85 }
86
87 QgsVectorLayerRef mappingTableRef = mMappingTable;
88 QgsMapLayer *mappingLayer = mappingTableRef.resolveWeakly( project, matchType );
89 if ( mappingLayer )
90 {
91 relationLeft.setReferencingLayer( mappingLayer->id() );
92 }
93
94 for ( int i = 0 ; i < std::min( mMappingReferencedLayerFields.size(), mReferencedLayerFields.size() ); ++i )
95 {
96 relationLeft.addFieldPair( mMappingReferencedLayerFields.at( i ), mReferencedLayerFields.at( i ) );
97 }
98
99 res.push_back( relationLeft );
100
101 QgsRelation relationRight;
102 relationRight.setId( mRelationId + QStringLiteral( "_backward" ) );
103 relationRight.setName( mRelationName + QStringLiteral( "_backward" ) );
104 relationRight.setStrength( mStrength );
105
106 QgsVectorLayerRef referencingLayerRef = mReferencingLayer;
107 QgsMapLayer *referencingLayer = referencingLayerRef.resolveWeakly( project, matchType );
108 if ( referencingLayer )
109 {
110 relationRight.setReferencedLayer( referencingLayer->id() );
111 }
112 if ( mappingLayer )
113 {
114 relationRight.setReferencingLayer( mappingLayer->id() );
115 }
116
117 for ( int i = 0 ; i < std::min( mMappingReferencingLayerFields.size(), mReferencingLayerFields.size() ); ++i )
118 {
119 relationRight.addFieldPair( mMappingReferencingLayerFields.at( i ), mReferencingLayerFields.at( i ) );
120 }
121
122 res.push_back( relationRight );
123 break;
124 }
125 }
126
127 return res;
128}
129
131{
132 return mReferencingLayer;
133}
134
136{
137 return mReferencingLayer.source;
138}
139
141{
142 return mReferencingLayer.provider;
143}
144
146{
147 if ( QgsProviderMetadata *metadata = QgsProviderRegistry::instance()->providerMetadata( mReferencingLayer.provider ) )
148 {
149 return metadata->decodeUri( mReferencingLayer.source ).value( QStringLiteral( "layerName" ) ).toString();
150 }
151 return QString();
152}
153
155{
156 return mReferencedLayer;
157}
158
160{
161 return mReferencedLayer.source;
162}
163
165{
166 return mReferencedLayer.provider;
167}
168
170{
171 if ( QgsProviderMetadata *metadata = QgsProviderRegistry::instance()->providerMetadata( mReferencedLayer.provider ) )
172 {
173 return metadata->decodeUri( mReferencedLayer.source ).value( QStringLiteral( "layerName" ) ).toString();
174 }
175 return QString();
176}
177
179{
180 return mMappingTable;
181}
182
184{
185 mMappingTable = table;
186}
187
189{
190 return mMappingTable.source;
191}
192
194{
195 return mMappingTable.provider;
196}
197
199{
200 if ( QgsProviderMetadata *metadata = QgsProviderRegistry::instance()->providerMetadata( mMappingTable.provider ) )
201 {
202 return metadata->decodeUri( mMappingTable.source ).value( QStringLiteral( "layerName" ) ).toString();
203 }
204 return QString();
205}
206
208{
209 return mStrength;
210}
211
212QgsWeakRelation QgsWeakRelation::readXml( const QgsVectorLayer *layer, WeakRelationType type, const QDomNode &node, const QgsPathResolver resolver )
213{
214 QDomElement relationElement = node.toElement();
215
216 if ( relationElement.tagName() != QLatin1String( "relation" ) )
217 {
218 QgsLogger::warning( QApplication::translate( "QgsRelation", "Cannot create relation. Unexpected tag '%1'" ).arg( relationElement.tagName() ) );
219 }
220
221 QStringList referencingFields;
222 QStringList referencedFields;
223 const QDomNodeList fieldPairNodes { relationElement.elementsByTagName( QStringLiteral( "fieldRef" ) ) };
224 for ( int j = 0; j < fieldPairNodes.length(); ++j )
225 {
226 const QDomElement fieldPairElement = fieldPairNodes.at( j ).toElement();
227 referencingFields.push_back( fieldPairElement.attribute( QStringLiteral( "referencingField" ) ) );
228 referencedFields.push_back( fieldPairElement.attribute( QStringLiteral( "referencedField" ) ) );
229 }
230
231 switch ( type )
232 {
233 case Referencing:
234 {
235 QgsWeakRelation rel{ relationElement.attribute( QStringLiteral( "id" ) ),
236 relationElement.attribute( QStringLiteral( "name" ) ),
237 static_cast<Qgis::RelationshipStrength>( relationElement.attribute( QStringLiteral( "strength" ) ).toInt() ),
238 // Referencing
239 layer->id(),
240 layer->name(),
241 resolver.writePath( layer->publicSource() ),
242 layer->providerType(),
243 // Referenced
244 relationElement.attribute( QStringLiteral( "layerId" ) ),
245 relationElement.attribute( QStringLiteral( "layerName" ) ),
246 relationElement.attribute( QStringLiteral( "dataSource" ) ),
247 relationElement.attribute( QStringLiteral( "providerKey" ) )
248 };
249 rel.setReferencedLayerFields( referencedFields );
250 rel.setReferencingLayerFields( referencingFields );
251 return rel;
252 }
253
254 case Referenced:
255 {
256 QgsWeakRelation rel{ relationElement.attribute( QStringLiteral( "id" ) ),
257 relationElement.attribute( QStringLiteral( "name" ) ),
258 static_cast<Qgis::RelationshipStrength>( relationElement.attribute( QStringLiteral( "strength" ) ).toInt() ),
259 // Referencing
260 relationElement.attribute( QStringLiteral( "layerId" ) ),
261 relationElement.attribute( QStringLiteral( "layerName" ) ),
262 relationElement.attribute( QStringLiteral( "dataSource" ) ),
263 relationElement.attribute( QStringLiteral( "providerKey" ) ),
264 // Referenced
265 layer->id(),
266 layer->name(),
267 resolver.writePath( layer->publicSource() ),
268 layer->providerType()
269 };
270 rel.setReferencedLayerFields( referencedFields );
271 rel.setReferencingLayerFields( referencingFields );
272 return rel;
273 }
274 }
275
276 // avoid build warnings
277 return QgsWeakRelation();
278}
279
280void QgsWeakRelation::writeXml( const QgsVectorLayer *layer, WeakRelationType type, const QgsRelation &relation, QDomNode &node, QDomDocument &doc )
281{
282 if ( !layer )
283 return;
284
285 if ( layer != relation.referencingLayer() && layer != relation.referencedLayer() )
286 return;
287
288 const QgsPathResolver resolver { QgsProject::instance()->pathResolver() };
289
290 relation.writeXml( node, doc );
291 QDomNodeList relationsNodeList = node.toElement().elementsByTagName( QStringLiteral( "relation" ) );
292 QDomElement relationElement;
293
294 for ( int i = 0; i < relationsNodeList.size(); ++i )
295 {
296 relationElement = relationsNodeList.at( i ).toElement();
297 if ( relationElement.hasAttribute( QStringLiteral( "id" ) ) && relationElement.attribute( QStringLiteral( "id" ) ) == relation.id() )
298 {
299 switch ( type )
300 {
301 case Referencing:
302 // if the layer is the referencing one, we save the referenced layer info
303 relationElement.setAttribute( QStringLiteral( "layerId" ), relation.referencedLayer()->id() );
304 relationElement.setAttribute( QStringLiteral( "layerName" ), relation.referencedLayer()->name() );
305 relationElement.setAttribute( QStringLiteral( "dataSource" ), resolver.writePath( relation.referencedLayer()->publicSource() ) );
306 relationElement.setAttribute( QStringLiteral( "providerKey" ), relation.referencedLayer()->providerType() );
307 break;
308
309 case Referenced:
310 // if the layer is the referenced one, we save the referencing layer info
311 relationElement.setAttribute( QStringLiteral( "layerId" ), relation.referencingLayer()->id() );
312 relationElement.setAttribute( QStringLiteral( "layerName" ), relation.referencingLayer()->name() );
313 relationElement.setAttribute( QStringLiteral( "dataSource" ), resolver.writePath( relation.referencingLayer()->publicSource() ) );
314 relationElement.setAttribute( QStringLiteral( "providerKey" ), relation.referencingLayer()->providerType() );
315 break;
316 }
317 }
318 }
319}
RelationshipStrength
Relationship strength.
Definition: qgis.h:2642
@ ManyToMany
Many to many relationship.
@ ManyToOne
Many to one relationship.
@ OneToOne
One to one relationship.
@ OneToMany
One to many relationship.
static void warning(const QString &msg)
Goes to qWarning.
Definition: qgslogger.cpp:122
Base class for all map layer types.
Definition: qgsmaplayer.h:73
QString name
Definition: qgsmaplayer.h:76
QString providerType() const
Returns the provider type (provider key) for this layer.
QString publicSource() const
Gets a version of the internal layer definition that has sensitive bits removed (for example,...
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
Resolves relative paths into absolute paths and vice versa.
QString writePath(const QString &filename) const
Prepare a filename to save it to the project file.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition: qgsproject.h:105
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:477
QgsPathResolver pathResolver() const
Returns path resolver object with considering whether the project uses absolute or relative paths and...
Holds data provider key, description, and associated shared library file or function pointer informat...
static QgsProviderRegistry * instance(const QString &pluginPath=QString())
Means of accessing canonical single instance.
void setId(const QString &id)
Set an id for this relation.
void setReferencedLayer(const QString &id)
Set the referenced (parent) layer id.
QgsVectorLayer * referencedLayer
Definition: qgsrelation.h:47
void setStrength(Qgis::RelationshipStrength strength)
Set a strength for this relation.
void addFieldPair(const QString &referencingField, const QString &referencedField)
Add a field pair which is part of this relation The first element of each pair are the field names of...
void setReferencingLayer(const QString &id)
Set the referencing (child) layer id.
Q_GADGET QString id
Definition: qgsrelation.h:45
QgsVectorLayer * referencingLayer
Definition: qgsrelation.h:46
void setName(const QString &name)
Set a name for this relation.
void writeXml(QDomNode &node, QDomDocument &doc) const
Writes a relation to an XML structure.
Represents a vector layer which manages a vector based data sets.
The QgsWeakRelation class represent a QgsRelation with possibly unresolved layers or unmatched fields...
QgsVectorLayerRef referencedLayer() const
Returns a weak reference to the referenced (or "parent" / "left") layer.
QList< QgsRelation > resolvedRelations(const QgsProject *project, QgsVectorLayerRef::MatchType matchType=QgsVectorLayerRef::MatchType::All) const
Resolves a weak relation in the given project returning a list of possibly invalid QgsRelations and w...
void setMappingTable(const QgsVectorLayerRef &table)
Sets a weak reference to the mapping table, which forms the middle table in many-to-many relationship...
WeakRelationType
Enum to distinguish if the layer is referenced or referencing.
@ Referencing
The layer is referencing (or the "child" / "right" layer in the relationship)
@ Referenced
The layer is referenced (or the "parent" / "left" left in the relationship)
QString referencedLayerProvider() const
Returns the provider ID for the referenced (or "parent" / "left") layer.
QgsWeakRelation()
Default constructor for an invalid relation.
QString mappingTableProvider() const
Returns the provider ID for the mapping table, which forms the middle table in many-to-many relations...
QString mappingTableName() const
Returns the layer name of the mapping table, which forms the middle table in many-to-many relationshi...
QString mappingTableSource() const
Returns the source URI for the mapping table, which forms the middle table in many-to-many relationsh...
QString referencingLayerProvider() const
Returns the provider ID for the referencing (or "child" / "right") layer.
QgsVectorLayerRef referencingLayer() const
Returns a weak reference to the referencing (or "child" / "right") layer.
QString referencedLayerName() const
Returns the layer name of the referenced (or "parent" / "left") layer.
static void writeXml(const QgsVectorLayer *layer, WeakRelationType type, const QgsRelation &relation, QDomNode &node, QDomDocument &doc)
Writes a weak relation infoto an XML structure.
static QgsWeakRelation readXml(const QgsVectorLayer *layer, WeakRelationType type, const QDomNode &node, const QgsPathResolver resolver)
Returns a weak relation for the given layer.
QString referencedLayerSource() const
Returns the source URI for the referenced (or "parent" / "left") layer.
QString referencingLayerSource() const
Returns the source URI for the referencing (or "child" / "right") layer.
QgsVectorLayerRef mappingTable() const
Returns a weak reference to the mapping table, which forms the middle table in many-to-many relations...
QString referencingLayerName() const
Returns the layer name of the referencing (or "child" / "right") layer.
Qgis::RelationshipStrength strength() const
Returns the strength of the relation.
TYPE * resolveWeakly(const QgsProject *project, MatchType matchType=MatchType::All)
Resolves the map layer by attempting to find a matching layer in a project using a weak match.
MatchType
Flag for match type in weak resolution.
QString source
Weak reference to layer public source.
QString provider
Weak reference to layer provider.