Branch data     Line data    Source code

       1                 :            : /***************************************************************************
       2                 :            :     qgsgeonoderequest.h
       3                 :            :     ---------------------
       4                 :            :     begin                : Jul 2017
       5                 :            :     copyright            : (C) 2017 by Muhammad Yarjuna Rohmat, Ismail Sunni
       6                 :            :     email                : rohmat at kartoza dot com, ismail at kartoza dot com
       7                 :            :  ***************************************************************************
       8                 :            :  *                                                                         *
       9                 :            :  *   This program is free software; you can redistribute it and/or modify  *
      10                 :            :  *   it under the terms of the GNU General Public License as published by  *
      11                 :            :  *   the Free Software Foundation; either version 2 of the License, or     *
      12                 :            :  *   (at your option) any later version.                                   *
      13                 :            :  *                                                                         *
      14                 :            :  ***************************************************************************/
      15                 :            : 
      16                 :            : #include "qgsnetworkaccessmanager.h"
      17                 :            : #include "qgssettings.h"
      18                 :            : #include "qgsmessagelog.h"
      19                 :            : #include "qgslogger.h"
      20                 :            : #include "qgsgeonoderequest.h"
      21                 :            : 
      22                 :            : #include <QEventLoop>
      23                 :            : #include <QNetworkCacheMetaData>
      24                 :            : #include <QByteArray>
      25                 :            : #include <QJsonDocument>
      26                 :            : #include <QJsonObject>
      27                 :            : #include <QUrl>
      28                 :            : #include <QDomDocument>
      29                 :            : #include <QRegularExpression>
      30                 :            : 
      31                 :          0 : QgsGeoNodeRequest::QgsGeoNodeRequest( const QString &baseUrl, bool forceRefresh, QObject *parent )
      32                 :          0 :   : QObject( parent )
      33                 :          0 :   , mBaseUrl( baseUrl )
      34                 :          0 :   , mForceRefresh( forceRefresh )
      35                 :          0 : {
      36                 :            : 
      37                 :          0 : }
      38                 :            : 
      39                 :          0 : QgsGeoNodeRequest::~QgsGeoNodeRequest()
      40                 :          0 : {
      41                 :          0 :   abort();
      42                 :          0 : }
      43                 :            : 
      44                 :          0 : void QgsGeoNodeRequest::abort()
      45                 :            : {
      46                 :          0 :   mIsAborted = true;
      47                 :          0 :   if ( mGeoNodeReply )
      48                 :            :   {
      49                 :          0 :     mGeoNodeReply->deleteLater();
      50                 :          0 :     mGeoNodeReply = nullptr;
      51                 :          0 :   }
      52                 :          0 : }
      53                 :            : 
      54                 :          0 : void QgsGeoNodeRequest::fetchLayers()
      55                 :            : {
      56                 :          0 :   request( QStringLiteral( "/api/layers/" ) );
      57                 :          0 :   QObject *obj = new QObject( this );
      58                 :            : 
      59                 :          0 :   connect( this, &QgsGeoNodeRequest::requestFinished, obj, [obj, this ]
      60                 :            :   {
      61                 :          0 :     QList<QgsGeoNodeRequest::ServiceLayerDetail> layers;
      62                 :          0 :     if ( mError.isEmpty() )
      63                 :            :     {
      64                 :          0 :       layers = parseLayers( this->lastResponse() );
      65                 :          0 :     }
      66                 :          0 :     emit layersFetched( layers );
      67                 :            : 
      68                 :          0 :     obj->deleteLater();
      69                 :          0 :   } );
      70                 :          0 : }
      71                 :            : 
      72                 :          0 : QList<QgsGeoNodeRequest::ServiceLayerDetail> QgsGeoNodeRequest::fetchLayersBlocking()
      73                 :            : {
      74                 :          0 :   QList<QgsGeoNodeRequest::ServiceLayerDetail> layers;
      75                 :            : 
      76                 :          0 :   QEventLoop loop;
      77                 :          0 :   connect( this, &QgsGeoNodeRequest::requestFinished, &loop, &QEventLoop::quit );
      78                 :          0 :   QObject *obj = new QObject( this );
      79                 :          0 :   connect( this, &QgsGeoNodeRequest::layersFetched, obj, [&]( const QList<QgsGeoNodeRequest::ServiceLayerDetail> &fetched )
      80                 :            :   {
      81                 :          0 :     layers = fetched;
      82                 :          0 :   } );
      83                 :          0 :   fetchLayers();
      84                 :          0 :   loop.exec( QEventLoop::ExcludeUserInputEvents );
      85                 :          0 :   delete obj;
      86                 :          0 :   return layers;
      87                 :          0 : }
      88                 :            : 
      89                 :          0 : QgsGeoNodeStyle QgsGeoNodeRequest::fetchDefaultStyleBlocking( const QString &layerName )
      90                 :            : {
      91                 :          0 :   QgsGeoNodeStyle defaultStyle;
      92                 :          0 :   bool success = requestBlocking( QStringLiteral( "/api/layers?name=" )  + layerName );
      93                 :          0 :   if ( !success )
      94                 :            :   {
      95                 :          0 :     return defaultStyle;
      96                 :            :   }
      97                 :            : 
      98                 :          0 :   const QJsonDocument jsonDocument = QJsonDocument::fromJson( this->lastResponse() );
      99                 :          0 :   const QJsonObject jsonObject = jsonDocument.object();
     100                 :          0 :   const QList<QVariant> layers = jsonObject.toVariantMap().value( QStringLiteral( "objects" ) ).toList();
     101                 :          0 :   if ( layers.count() < 1 )
     102                 :            :   {
     103                 :          0 :     return defaultStyle;
     104                 :            :   }
     105                 :          0 :   QString defaultStyleUrl = layers.at( 0 ).toMap().value( QStringLiteral( "default_style" ) ).toString();
     106                 :            : 
     107                 :          0 :   defaultStyle = retrieveStyle( defaultStyleUrl );
     108                 :            : 
     109                 :          0 :   return defaultStyle;
     110                 :            : 
     111                 :          0 : }
     112                 :            : 
     113                 :          0 : QList<QgsGeoNodeStyle> QgsGeoNodeRequest::fetchStylesBlocking( const QString &layerName )
     114                 :            : {
     115                 :          0 :   QList<QgsGeoNodeStyle> geoNodeStyles;
     116                 :          0 :   bool success = requestBlocking( QStringLiteral( "/api/styles?layer__name=" ) + layerName );
     117                 :          0 :   if ( !success )
     118                 :            :   {
     119                 :          0 :     return geoNodeStyles;
     120                 :            :   }
     121                 :            : 
     122                 :          0 :   const QJsonDocument jsonDocument = QJsonDocument::fromJson( this->lastResponse() );
     123                 :          0 :   const QJsonObject jsobObject = jsonDocument.object();
     124                 :          0 :   const QList<QVariant> styles = jsobObject.toVariantMap().value( QStringLiteral( "objects" ) ).toList();
     125                 :            : 
     126                 :          0 :   for ( const QVariant &style : styles )
     127                 :            :   {
     128                 :          0 :     const QVariantMap styleMap = style.toMap();
     129                 :          0 :     QString styleUrl = styleMap.value( QStringLiteral( "resource_uri" ) ).toString();
     130                 :          0 :     QgsGeoNodeStyle geoNodeStyle = retrieveStyle( styleUrl );
     131                 :          0 :     if ( !geoNodeStyle.name.isEmpty() )
     132                 :            :     {
     133                 :          0 :       geoNodeStyles.append( geoNodeStyle );
     134                 :          0 :     }
     135                 :          0 :   }
     136                 :            : 
     137                 :          0 :   return geoNodeStyles;
     138                 :            : 
     139                 :          0 : }
     140                 :            : 
     141                 :          0 : QgsGeoNodeStyle QgsGeoNodeRequest::fetchStyleBlocking( const QString &styleId )
     142                 :            : {
     143                 :          0 :   QString endPoint = QStringLiteral( "/api/styles/" ) + styleId;
     144                 :            : 
     145                 :          0 :   return retrieveStyle( endPoint );
     146                 :          0 : }
     147                 :            : 
     148                 :          0 : void QgsGeoNodeRequest::replyProgress( qint64 bytesReceived, qint64 bytesTotal )
     149                 :            : {
     150                 :          0 :   QString msg = tr( "%1 of %2 bytes of request downloaded." ).arg( bytesReceived ).arg( bytesTotal < 0 ? QStringLiteral( "unknown number of" ) : QString::number( bytesTotal ) );
     151                 :          0 :   QgsDebugMsgLevel( msg, 3 );
     152                 :          0 :   emit statusChanged( msg );
     153                 :          0 : }
     154                 :            : 
     155                 :          0 : QString QgsGeoNodeRequest::protocol() const
     156                 :            : {
     157                 :          0 :   return mProtocol;
     158                 :            : }
     159                 :            : 
     160                 :          0 : void QgsGeoNodeRequest::setProtocol( const QString &protocol )
     161                 :            : {
     162                 :          0 :   mProtocol = protocol;
     163                 :          0 : }
     164                 :            : 
     165                 :          0 : void QgsGeoNodeRequest::replyFinished()
     166                 :            : {
     167                 :          0 :   QgsDebugMsgLevel( QStringLiteral( "Reply finished" ), 2 );
     168                 :          0 :   if ( !mIsAborted && mGeoNodeReply )
     169                 :            :   {
     170                 :          0 :     if ( mGeoNodeReply->error() == QNetworkReply::NoError )
     171                 :            :     {
     172                 :          0 :       QgsDebugMsgLevel( QStringLiteral( "reply OK" ), 2 );
     173                 :          0 :       QVariant redirect = mGeoNodeReply->attribute( QNetworkRequest::RedirectionTargetAttribute );
     174                 :          0 :       if ( !redirect.isNull() )
     175                 :            :       {
     176                 :            : 
     177                 :          0 :         emit statusChanged( QStringLiteral( "GeoNode request redirected." ) );
     178                 :            : 
     179                 :          0 :         const QUrl &toUrl = redirect.toUrl();
     180                 :          0 :         if ( toUrl == mGeoNodeReply->url() )
     181                 :            :         {
     182                 :          0 :           mError = tr( "Redirect loop detected: %1" ).arg( toUrl.toString() );
     183                 :          0 :           QgsMessageLog::logMessage( mError, tr( "GeoNode" ) );
     184                 :          0 :           mHttpGeoNodeResponse.clear();
     185                 :          0 :         }
     186                 :            :         else
     187                 :            :         {
     188                 :          0 :           QNetworkRequest request( toUrl );
     189                 :          0 :           QgsSetRequestInitiatorClass( request, QStringLiteral( "QgsGeoNodeRequest" ) );
     190                 :          0 :           request.setAttribute( QNetworkRequest::CacheLoadControlAttribute, mForceRefresh ? QNetworkRequest::AlwaysNetwork : QNetworkRequest::PreferCache );
     191                 :          0 :           request.setAttribute( QNetworkRequest::CacheSaveControlAttribute, true );
     192                 :            : 
     193                 :          0 :           mGeoNodeReply->deleteLater();
     194                 :          0 :           mGeoNodeReply = nullptr;
     195                 :            : 
     196                 :          0 :           QgsDebugMsgLevel( QStringLiteral( "redirected getcapabilities: %1 forceRefresh=%2" ).arg( redirect.toString() ).arg( mForceRefresh ), 3 );
     197                 :          0 :           mGeoNodeReply = QgsNetworkAccessManager::instance()->get( request );
     198                 :            : 
     199                 :          0 :           connect( mGeoNodeReply, &QNetworkReply::finished, this, &QgsGeoNodeRequest::replyFinished, Qt::DirectConnection );
     200                 :          0 :           connect( mGeoNodeReply, &QNetworkReply::downloadProgress, this, &QgsGeoNodeRequest::replyProgress, Qt::DirectConnection );
     201                 :            :           return;
     202                 :          0 :         }
     203                 :          0 :       }
     204                 :            :       else
     205                 :            :       {
     206                 :          0 :         const QgsNetworkAccessManager *nam = QgsNetworkAccessManager::instance();
     207                 :            : 
     208                 :          0 :         if ( nam->cache() )
     209                 :            :         {
     210                 :          0 :           QNetworkCacheMetaData cmd = nam->cache()->metaData( mGeoNodeReply->request().url() );
     211                 :            : 
     212                 :          0 :           QNetworkCacheMetaData::RawHeaderList hl;
     213                 :          0 :           const QNetworkCacheMetaData::RawHeaderList cmdHeaders = cmd.rawHeaders();
     214                 :          0 :           for ( const QNetworkCacheMetaData::RawHeader &h : cmdHeaders )
     215                 :            :           {
     216                 :          0 :             if ( h.first != QStringLiteral( "Cache-Control" ) )
     217                 :          0 :               hl.append( h );
     218                 :            :           }
     219                 :          0 :           cmd.setRawHeaders( hl );
     220                 :            : 
     221                 :          0 :           QgsDebugMsgLevel( QStringLiteral( "expirationDate:%1" ).arg( cmd.expirationDate().toString() ), 2 );
     222                 :          0 :           if ( cmd.expirationDate().isNull() )
     223                 :            :           {
     224                 :          0 :             QgsSettings settings;
     225                 :          0 :             cmd.setExpirationDate( QDateTime::currentDateTime().addSecs( settings.value( QStringLiteral( "qgis/defaultCapabilitiesExpiry" ), "24", QgsSettings::Providers ).toInt() * 60 * 60 ) );
     226                 :          0 :           }
     227                 :            : 
     228                 :          0 :           nam->cache()->updateMetaData( cmd );
     229                 :          0 :         }
     230                 :            :         else
     231                 :            :         {
     232                 :          0 :           QgsDebugMsg( QStringLiteral( "No cache for capabilities!" ) );
     233                 :            :         }
     234                 :            : 
     235                 :          0 :         mHttpGeoNodeResponse = mGeoNodeReply->readAll();
     236                 :            : 
     237                 :          0 :         if ( mHttpGeoNodeResponse.isEmpty() )
     238                 :            :         {
     239                 :          0 :           mError = tr( "Empty capabilities: %1" ).arg( mGeoNodeReply->errorString() );
     240                 :          0 :         }
     241                 :            :       }
     242                 :          0 :     }
     243                 :            :     else
     244                 :            :     {
     245                 :          0 :       mError = tr( "Request failed: %1" ).arg( mGeoNodeReply->errorString() );
     246                 :          0 :       QgsMessageLog::logMessage( mError, tr( "GeoNode" ) );
     247                 :          0 :       mHttpGeoNodeResponse.clear();
     248                 :            :     }
     249                 :          0 :   }
     250                 :            : 
     251                 :          0 :   if ( mGeoNodeReply )
     252                 :            :   {
     253                 :          0 :     mGeoNodeReply->deleteLater();
     254                 :          0 :     mGeoNodeReply = nullptr;
     255                 :          0 :   }
     256                 :            : 
     257                 :          0 :   emit requestFinished();
     258                 :          0 : }
     259                 :            : 
     260                 :          0 : QList<QgsGeoNodeRequest::ServiceLayerDetail> QgsGeoNodeRequest::parseLayers( const QByteArray &layerResponse )
     261                 :            : {
     262                 :          0 :   QList<QgsGeoNodeRequest::ServiceLayerDetail> layers;
     263                 :          0 :   if ( layerResponse.isEmpty() )
     264                 :            :   {
     265                 :          0 :     return layers;
     266                 :            :   }
     267                 :            : 
     268                 :          0 :   const QJsonDocument jsonDocument = QJsonDocument::fromJson( layerResponse );
     269                 :          0 :   const QJsonObject jsonObject = jsonDocument.object();
     270                 :          0 :   const QVariantMap jsonVariantMap = jsonObject.toVariantMap();
     271                 :          0 :   const QVariantList layerList = jsonVariantMap.value( QStringLiteral( "objects" ) ).toList();
     272                 :          0 : 
     273                 :          0 :   QString wmsURLFormat, wfsURLFormat, xyzURLFormat;
     274                 :            : 
     275                 :          0 :   for ( const QVariant &layer : std::as_const( layerList ) )
     276                 :            :   {
     277                 :          0 :     QgsGeoNodeRequest::ServiceLayerDetail layerStruct;
     278                 :          0 :     const QVariantMap layerMap = layer.toMap();
     279                 :          0 :     QVariantList layerLinks = layerMap.value( QStringLiteral( "links" ) ).toList();
     280                 :            : 
     281                 :          0 :     if ( layerMap.value( QStringLiteral( "typename" ) ).toString().isEmpty() )
     282                 :            :     {
     283                 :          0 :       const QStringList splitUrl = layerMap.value( QStringLiteral( "detail_url" ) ).toString().split( '/' );
     284                 :          0 :       layerStruct.typeName = !splitUrl.isEmpty() ? splitUrl.last() : QString();
     285                 :          0 :     }
     286                 :          0 :     layerStruct.uuid = QUuid( layerMap.value( QStringLiteral( "uuid" ) ).toString() );
     287                 :          0 :     layerStruct.id = layerMap.value( QStringLiteral( "id" ) ).toString();
     288                 :          0 :     layerStruct.name = layerMap.value( QStringLiteral( "name" ) ).toString();
     289                 :          0 :     layerStruct.typeName = layerMap.value( QStringLiteral( "typename" ) ).toString();
     290                 :          0 :     layerStruct.title = layerMap.value( QStringLiteral( "title" ) ).toString();
     291                 :            : 
     292                 :          0 :     if ( ! layerMap.contains( QStringLiteral( "links" ) ) )
     293                 :            :     {
     294                 :          0 :       if ( wmsURLFormat.isEmpty() && wfsURLFormat.isEmpty() && xyzURLFormat.isEmpty() )
     295                 :            :       {
     296                 :          0 :         bool success = requestBlocking( QStringLiteral( "/api/layers/" ) + layerStruct.id );
     297                 :          0 :         if ( success )
     298                 :            :         {
     299                 :          0 :           const QJsonDocument resourceUriDocument = QJsonDocument::fromJson( this->lastResponse() );
     300                 :          0 :           const QJsonObject resourceUriObject = resourceUriDocument.object();
     301                 :          0 :           const QVariantMap resourceUriMap = resourceUriObject.toVariantMap();
     302                 :          0 :           QVariantList resourceUriLinks = resourceUriMap.value( QStringLiteral( "links" ) ).toList();
     303                 :          0 :           QgsGeoNodeRequest::ServiceLayerDetail tempLayerStruct;
     304                 :          0 :           tempLayerStruct = parseOwsUrl( tempLayerStruct, resourceUriLinks );
     305                 :            : 
     306                 :          0 :           if ( tempLayerStruct.wmsURL.isEmpty() && tempLayerStruct.wfsURL.isEmpty() && tempLayerStruct.xyzURL.isEmpty() )
     307                 :          0 :             continue;
     308                 :            : 
     309                 :            :           // Avoid iterating all the layers to get the service url. Instead, generate a string format once we found one service url
     310                 :            :           // for every service (wms, wfs, xyz). And then use the string format for the other layers since they are identical.
     311                 :          0 :           switch ( tempLayerStruct.server )
     312                 :            :           {
     313                 :            :             case QgsGeoNodeRequest::BackendServer::QgisServer:
     314                 :            :             {
     315                 :          0 :               wmsURLFormat = ! tempLayerStruct.wmsURL.isEmpty() ? tempLayerStruct.wmsURL.replace( layerStruct.name, QStringLiteral( "%1" ) ) : QString();
     316                 :          0 :               wfsURLFormat = ! tempLayerStruct.wfsURL.isEmpty() ? tempLayerStruct.wfsURL.replace( layerStruct.name, QStringLiteral( "%1" ) ) : QString();
     317                 :          0 :               xyzURLFormat = ! tempLayerStruct.xyzURL.isEmpty() ? tempLayerStruct.xyzURL.replace( layerStruct.name, QStringLiteral( "%1" ) ) : QString();
     318                 :          0 :               break;
     319                 :            :             }
     320                 :            :             case QgsGeoNodeRequest::BackendServer::Geoserver:
     321                 :            :             {
     322                 :          0 :               wmsURLFormat = ! tempLayerStruct.wmsURL.isEmpty() ? tempLayerStruct.wmsURL : QString();
     323                 :          0 :               wfsURLFormat = ! tempLayerStruct.wfsURL.isEmpty() ? tempLayerStruct.wfsURL : QString();
     324                 :          0 :               xyzURLFormat = ! tempLayerStruct.xyzURL.isEmpty() ? tempLayerStruct.xyzURL.replace( layerStruct.name, QStringLiteral( "%1" ) ) : QString();
     325                 :          0 :               break;
     326                 :            :             }
     327                 :            :             case QgsGeoNodeRequest::BackendServer::Unknown:
     328                 :          0 :               break;
     329                 :            :           }
     330                 :          0 :         }
     331                 :            :         else
     332                 :          0 :           continue;
     333                 :          0 :       }
     334                 :            :       else
     335                 :            :       {
     336                 :            :         // Replace string argument with the layer id.
     337                 :          0 :         layerStruct.wmsURL = wmsURLFormat.contains( "%1" ) ? wmsURLFormat.arg( layerStruct.name ) : wmsURLFormat;
     338                 :          0 :         layerStruct.wfsURL = wfsURLFormat.contains( "%1" ) ? wfsURLFormat.arg( layerStruct.name ) : wfsURLFormat;
     339                 :          0 :         layerStruct.xyzURL = xyzURLFormat.contains( "%1" ) ? xyzURLFormat.arg( layerStruct.name ) : xyzURLFormat;
     340                 :            :       }
     341                 :          0 :     }
     342                 :            :     else
     343                 :          0 :       layerStruct = parseOwsUrl( layerStruct, layerLinks );
     344                 :            : 
     345                 :          0 :     layers.append( layerStruct );
     346                 :          0 :   }
     347                 :            : 
     348                 :          0 :   return layers;
     349                 :          0 : }
     350                 :            : 
     351                 :          0 : QgsGeoNodeRequest::ServiceLayerDetail QgsGeoNodeRequest::parseOwsUrl( QgsGeoNodeRequest::ServiceLayerDetail &layerStruct, const QVariantList &layerLinks )
     352                 :            : {
     353                 :          0 :   QString urlFound;
     354                 :          0 :   for ( const QVariant &link : layerLinks )
     355                 :            :   {
     356                 :          0 :     const QVariantMap linkMap = link.toMap();
     357                 :          0 :     if ( linkMap.contains( QStringLiteral( "link_type" ) ) )
     358                 :            :     {
     359                 :          0 :       if ( linkMap.value( QStringLiteral( "link_type" ) ) == QLatin1String( "OGC:WMS" ) )
     360                 :            :       {
     361                 :          0 :         urlFound = layerStruct.wmsURL = linkMap.value( QStringLiteral( "url" ) ).toString();
     362                 :          0 :       }
     363                 :          0 :       else if ( linkMap.value( QStringLiteral( "link_type" ) ) == QLatin1String( "OGC:WFS" ) )
     364                 :            :       {
     365                 :          0 :         urlFound = layerStruct.wfsURL = linkMap.value( QStringLiteral( "url" ) ).toString();
     366                 :          0 :       }
     367                 :          0 :       else if ( linkMap.value( QStringLiteral( "link_type" ) ) == QLatin1String( "image" ) )
     368                 :            :       {
     369                 :          0 :         if ( linkMap.contains( QStringLiteral( "name" ) ) && linkMap.value( QStringLiteral( "name" ) ) == QLatin1String( "Tiles" ) )
     370                 :            :         {
     371                 :          0 :           urlFound = layerStruct.xyzURL = linkMap.value( QStringLiteral( "url" ) ).toString();
     372                 :          0 :         }
     373                 :          0 :       }
     374                 :          0 :     }
     375                 :            : 
     376                 :          0 :     switch ( layerStruct.server )
     377                 :            :     {
     378                 :            :       case QgsGeoNodeRequest::BackendServer::Geoserver:
     379                 :            :       case QgsGeoNodeRequest::BackendServer::QgisServer:
     380                 :          0 :         break;
     381                 :            : 
     382                 :            :       case QgsGeoNodeRequest::BackendServer::Unknown:
     383                 :            :       {
     384                 :          0 :         layerStruct.server = urlFound.contains( QStringLiteral( "qgis-server" ) ) ? QgsGeoNodeRequest::BackendServer::QgisServer : QgsGeoNodeRequest::BackendServer::Geoserver;
     385                 :          0 :         break;
     386                 :            :       }
     387                 :            :     }
     388                 :          0 :   }
     389                 :            : 
     390                 :          0 :   return layerStruct;
     391                 :          0 : }
     392                 :            : 
     393                 :          0 : QgsGeoNodeStyle QgsGeoNodeRequest::retrieveStyle( const QString &styleUrl )
     394                 :            : {
     395                 :          0 :   QgsGeoNodeStyle geoNodeStyle;
     396                 :            : 
     397                 :          0 :   bool success = requestBlocking( styleUrl );
     398                 :          0 :   if ( !success )
     399                 :            :   {
     400                 :          0 :     return geoNodeStyle;
     401                 :            :   }
     402                 :          0 :   const QJsonDocument jsonDocument = QJsonDocument::fromJson( this->lastResponse() );
     403                 :          0 :   const QJsonObject jsonObject = jsonDocument.object();
     404                 :            : 
     405                 :          0 :   const QVariantMap jsonMap = jsonObject.toVariantMap();
     406                 :          0 :   geoNodeStyle.id = jsonMap.value( QStringLiteral( "id" ) ).toString();
     407                 :          0 :   geoNodeStyle.name = jsonMap.value( QStringLiteral( "name" ) ).toString();
     408                 :          0 :   geoNodeStyle.title = jsonMap.value( QStringLiteral( "title" ) ).toString();
     409                 :          0 :   geoNodeStyle.styleUrl = jsonMap.value( QStringLiteral( "style_url" ) ).toString();
     410                 :            : 
     411                 :          0 :   success = requestBlocking( geoNodeStyle.styleUrl );
     412                 :          0 :   if ( !success )
     413                 :            :   {
     414                 :          0 :     return geoNodeStyle;
     415                 :            :   }
     416                 :            : 
     417                 :          0 :   success = geoNodeStyle.body.setContent( this->lastResponse() );
     418                 :          0 :   if ( !success )
     419                 :            :   {
     420                 :          0 :     return geoNodeStyle;
     421                 :            :   }
     422                 :            : 
     423                 :          0 :   return geoNodeStyle;
     424                 :          0 : }
     425                 :            : 
     426                 :          0 : QStringList QgsGeoNodeRequest::fetchServiceUrlsBlocking( const QString &serviceType )
     427                 :            : {
     428                 :          0 :   QStringList urls;
     429                 :            : 
     430                 :          0 :   const QList<QgsGeoNodeRequest::ServiceLayerDetail> layers = fetchLayersBlocking();
     431                 :            : 
     432                 :          0 :   if ( layers.empty() )
     433                 :            :   {
     434                 :          0 :     return urls;
     435                 :            :   }
     436                 :            : 
     437                 :          0 :   for ( const QgsGeoNodeRequest::ServiceLayerDetail &layer : layers )
     438                 :            :   {
     439                 :          0 :     QString url;
     440                 :          0 :     if ( QString::compare( serviceType, QStringLiteral( "wms" ), Qt::CaseInsensitive ) == 0 )
     441                 :            :     {
     442                 :          0 :       url = layer.wmsURL;
     443                 :          0 :     }
     444                 :          0 :     else if ( QString::compare( serviceType, QStringLiteral( "wfs" ), Qt::CaseInsensitive ) == 0 )
     445                 :            :     {
     446                 :          0 :       url = layer.wfsURL;
     447                 :          0 :     }
     448                 :          0 :     else if ( QString::compare( serviceType, QStringLiteral( "xyz" ), Qt::CaseInsensitive ) == 0 )
     449                 :            :     {
     450                 :          0 :       url = layer.xyzURL;
     451                 :          0 :     }
     452                 :            : 
     453                 :          0 :     if ( url.isEmpty() )
     454                 :          0 :       continue;
     455                 :            : 
     456                 :          0 :     if ( !url.contains( QLatin1String( "://" ) ) )
     457                 :            :     {
     458                 :          0 :       url.prepend( protocol() );
     459                 :          0 :     }
     460                 :          0 :     if ( !urls.contains( url ) )
     461                 :            :     {
     462                 :          0 :       urls.append( url );
     463                 :          0 :     }
     464                 :          0 :   }
     465                 :            : 
     466                 :          0 :   return urls;
     467                 :          0 : }
     468                 :            : 
     469                 :          0 : QgsStringMap QgsGeoNodeRequest::fetchServiceUrlDataBlocking( const QString &serviceType )
     470                 :            : {
     471                 :          0 :   QgsStringMap urls;
     472                 :            : 
     473                 :          0 :   const QList<QgsGeoNodeRequest::ServiceLayerDetail> layers = fetchLayersBlocking();
     474                 :            : 
     475                 :          0 :   if ( layers.empty() )
     476                 :            :   {
     477                 :          0 :     return urls;
     478                 :            :   }
     479                 :            : 
     480                 :          0 :   for ( const QgsGeoNodeRequest::ServiceLayerDetail &layer : layers )
     481                 :            :   {
     482                 :          0 :     QString url;
     483                 :            : 
     484                 :          0 :     if ( QString::compare( serviceType, QStringLiteral( "wms" ), Qt::CaseInsensitive ) == 0 )
     485                 :            :     {
     486                 :          0 :       url = layer.wmsURL;
     487                 :          0 :     }
     488                 :          0 :     else if ( QString::compare( serviceType, QStringLiteral( "wfs" ), Qt::CaseInsensitive ) == 0 )
     489                 :            :     {
     490                 :          0 :       url = layer.wfsURL;
     491                 :          0 :     }
     492                 :          0 :     else if ( QString::compare( serviceType, QStringLiteral( "xyz" ), Qt::CaseInsensitive ) == 0 )
     493                 :            :     {
     494                 :          0 :       url = layer.xyzURL;
     495                 :          0 :     }
     496                 :            : 
     497                 :          0 :     if ( url.isEmpty() )
     498                 :          0 :       continue;
     499                 :            : 
     500                 :          0 :     QString layerName = layer.name;
     501                 :          0 :     if ( !url.contains( QLatin1String( "://" ) ) )
     502                 :            :     {
     503                 :          0 :       url.prepend( protocol() );
     504                 :          0 :     }
     505                 :          0 :     if ( !urls.contains( url ) )
     506                 :            :     {
     507                 :          0 :       urls.insert( layerName, url );
     508                 :          0 :     }
     509                 :          0 :   }
     510                 :            : 
     511                 :          0 :   return urls;
     512                 :          0 : }
     513                 :            : 
     514                 :          0 : void QgsGeoNodeRequest::request( const QString &endPoint )
     515                 :            : {
     516                 :          0 :   abort();
     517                 :          0 :   mIsAborted = false;
     518                 :            :   // Handle case where the endpoint is full url
     519                 :          0 :   QString url = endPoint.startsWith( mBaseUrl ) ? endPoint : mBaseUrl + endPoint;
     520                 :          0 :   QgsDebugMsgLevel( "Requesting to " + url, 2 );
     521                 :          0 :   setProtocol( url.split( QStringLiteral( "://" ) ).at( 0 ) );
     522                 :          0 :   QUrl layerUrl( url );
     523                 :          0 :   layerUrl.setScheme( protocol() );
     524                 :            : 
     525                 :          0 :   mError.clear();
     526                 :            : 
     527                 :          0 :   mGeoNodeReply = requestUrl( url );
     528                 :          0 :   connect( mGeoNodeReply, &QNetworkReply::finished, this, &QgsGeoNodeRequest::replyFinished, Qt::DirectConnection );
     529                 :          0 :   connect( mGeoNodeReply, &QNetworkReply::downloadProgress, this, &QgsGeoNodeRequest::replyProgress, Qt::DirectConnection );
     530                 :          0 : }
     531                 :            : 
     532                 :          0 : bool QgsGeoNodeRequest::requestBlocking( const QString &endPoint )
     533                 :            : {
     534                 :          0 :   request( endPoint );
     535                 :            : 
     536                 :          0 :   QEventLoop loop;
     537                 :          0 :   connect( this, &QgsGeoNodeRequest::requestFinished, &loop, &QEventLoop::quit );
     538                 :          0 :   loop.exec( QEventLoop::ExcludeUserInputEvents );
     539                 :            : 
     540                 :          0 :   return mError.isEmpty();
     541                 :          0 : }
     542                 :            : 
     543                 :          0 : QNetworkReply *QgsGeoNodeRequest::requestUrl( const QString &url )
     544                 :            : {
     545                 :          0 :   QNetworkRequest request( url );
     546                 :          0 :   request.setAttribute( QNetworkRequest::RedirectPolicyAttribute, 1 );
     547                 :            : 
     548                 :          0 :   QgsSetRequestInitiatorClass( request, QStringLiteral( "QgsGeoNodeRequest" ) );
     549                 :            :   // Add authentication check here
     550                 :            : 
     551                 :          0 :   request.setAttribute( QNetworkRequest::CacheLoadControlAttribute, mForceRefresh ? QNetworkRequest::AlwaysNetwork : QNetworkRequest::PreferCache );
     552                 :          0 :   request.setAttribute( QNetworkRequest::CacheSaveControlAttribute, true );
     553                 :            : 
     554                 :          0 :   return QgsNetworkAccessManager::instance()->get( request );
     555                 :          0 : }
     556                 :            : 
     557                 :            :