qgssensorthingsutils.cpp

Go to the documentation of this file.

/***************************************************************************
    qgssensorthingsutils.cpp
    --------------------
    begin                : November 2023
    copyright            : (C) 2023 by Nyall Dawson
    email                : nyall dot dawson at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgssensorthingsutils.h"
 
#include <nlohmann/json.hpp>
 
#include "qgsblockingnetworkrequest.h"
#include "qgsfield.h"
#include "qgsfields.h"
#include "qgslogger.h"
#include "qgsnetworkaccessmanager.h"
#include "qgsrectangle.h"
#include "qgssetrequestinitiator_p.h"
#include "qgswkbtypes.h"
 
#include <QNetworkRequest>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QString>
#include <QUrl>
 
using namespace Qt::StringLiterals;
 
//
// QgsSensorThingsExpansionDefinition
//
QgsSensorThingsExpansionDefinition::QgsSensorThingsExpansionDefinition( Qgis::SensorThingsEntity childEntity, const QString &orderBy, Qt::SortOrder sortOrder, int limit, const QString &filter )
  : mChildEntity( childEntity )
  , mOrderBy( orderBy )
  , mSortOrder( sortOrder )
  , mLimit( limit )
  , mFilter( filter )
{}
 
QgsSensorThingsExpansionDefinition QgsSensorThingsExpansionDefinition::defaultDefinitionForEntity( Qgis::SensorThingsEntity entity )
{
  switch ( entity )
  {
    case Qgis::SensorThingsEntity::Invalid:
      return QgsSensorThingsExpansionDefinition();
 
    case Qgis::SensorThingsEntity::Thing:
    case Qgis::SensorThingsEntity::Location:
    case Qgis::SensorThingsEntity::HistoricalLocation:
    case Qgis::SensorThingsEntity::Sensor:
    case Qgis::SensorThingsEntity::FeatureOfInterest:
    case Qgis::SensorThingsEntity::Feature:
    case Qgis::SensorThingsEntity::FeatureType:
    case Qgis::SensorThingsEntity::Deployment:
    case Qgis::SensorThingsEntity::ObservingProcedure:
    case Qgis::SensorThingsEntity::Sampling:
    case Qgis::SensorThingsEntity::SamplingProcedure:
    case Qgis::SensorThingsEntity::Sampler:
    case Qgis::SensorThingsEntity::PreparationStep:
    case Qgis::SensorThingsEntity::PreparationProcedure:
    case Qgis::SensorThingsEntity::DatastreamRelation:
    case Qgis::SensorThingsEntity::ThingRelation:
    case Qgis::SensorThingsEntity::RelationRole:
    case Qgis::SensorThingsEntity::ObservationRelation:
    case Qgis::SensorThingsEntity::FeatureRelation:
 
      // no special defaults for these entities
      return QgsSensorThingsExpansionDefinition( entity );
 
    case Qgis::SensorThingsEntity::Observation:
      // default to descending sort by phenomenonTime
      return QgsSensorThingsExpansionDefinition( Qgis::SensorThingsEntity::Observation, u"phenomenonTime"_s, Qt::SortOrder::DescendingOrder );
 
    case Qgis::SensorThingsEntity::Datastream:
    case Qgis::SensorThingsEntity::MultiDatastream:
    case Qgis::SensorThingsEntity::ObservedProperty:
      // use smaller limit by default
      return QgsSensorThingsExpansionDefinition( entity, QString(), Qt::SortOrder::AscendingOrder, 10 );
  }
  BUILTIN_UNREACHABLE
}
 
bool QgsSensorThingsExpansionDefinition::isValid() const
{
  return mChildEntity != Qgis::SensorThingsEntity::Invalid;
}
 
Qgis::SensorThingsEntity QgsSensorThingsExpansionDefinition::childEntity() const
{
  return mChildEntity;
}
 
void QgsSensorThingsExpansionDefinition::setChildEntity( Qgis::SensorThingsEntity entity )
{
  mChildEntity = entity;
}
 
Qt::SortOrder QgsSensorThingsExpansionDefinition::sortOrder() const
{
  return mSortOrder;
}
 
void QgsSensorThingsExpansionDefinition::setSortOrder( Qt::SortOrder order )
{
  mSortOrder = order;
}
 
int QgsSensorThingsExpansionDefinition::limit() const
{
  return mLimit;
}
 
void QgsSensorThingsExpansionDefinition::setLimit( int limit )
{
  mLimit = limit;
}
 
QString QgsSensorThingsExpansionDefinition::filter() const
{
  return mFilter;
}
 
void QgsSensorThingsExpansionDefinition::setFilter( const QString &filter )
{
  mFilter = filter;
}
 
QString QgsSensorThingsExpansionDefinition::toString() const
{
  if ( !isValid() )
    return QString();
 
  QStringList parts;
  parts.append( qgsEnumValueToKey( mChildEntity ) );
  if ( !mOrderBy.isEmpty() )
    parts.append( u"orderby=%1,%2"_s.arg( mOrderBy, mSortOrder == Qt::SortOrder::AscendingOrder ? u"asc"_s : u"desc"_s ) );
  if ( mLimit >= 0 )
    parts.append( u"limit=%1"_s.arg( mLimit ) );
  if ( !mFilter.trimmed().isEmpty() )
  {
    QString escapedFilter = mFilter;
    escapedFilter.replace( ':', "\\colon"_L1 );
    parts.append( u"filter=%1"_s.arg( escapedFilter ) );
  }
  return parts.join( ':' );
}
 
QgsSensorThingsExpansionDefinition QgsSensorThingsExpansionDefinition::fromString( const QString &string )
{
  const QStringList parts = string.split( ':', Qt::SkipEmptyParts );
  if ( parts.empty() )
    return QgsSensorThingsExpansionDefinition();
 
  QgsSensorThingsExpansionDefinition definition( qgsEnumKeyToValue( parts.at( 0 ), Qgis::SensorThingsEntity::Invalid ) );
  definition.setLimit( -1 );
  for ( int i = 1; i < parts.count(); ++i )
  {
    const QString &part = parts.at( i );
    const thread_local QRegularExpression orderByRegEx( u"^orderby=(.*),(.*?)$"_s );
    const thread_local QRegularExpression orderLimitRegEx( u"^limit=(\\d+)$"_s );
    const thread_local QRegularExpression filterRegEx( u"^filter=(.*)$"_s );
 
    const QRegularExpressionMatch orderByMatch = orderByRegEx.match( part );
    if ( orderByMatch.hasMatch() )
    {
      definition.setOrderBy( orderByMatch.captured( 1 ) );
      definition.setSortOrder( orderByMatch.captured( 2 ) == "asc"_L1 ? Qt::SortOrder::AscendingOrder : Qt::SortOrder::DescendingOrder );
      continue;
    }
 
    const QRegularExpressionMatch limitMatch = orderLimitRegEx.match( part );
    if ( limitMatch.hasMatch() )
    {
      definition.setLimit( limitMatch.captured( 1 ).toInt() );
      continue;
    }
 
    const QRegularExpressionMatch filterMatch = filterRegEx.match( part );
    if ( filterMatch.hasMatch() )
    {
      QString filter = filterMatch.captured( 1 );
      filter.replace( "\\colon"_L1, ":"_L1 );
      definition.setFilter( filter );
      continue;
    }
  }
  return definition;
}
 
QString QgsSensorThingsExpansionDefinition::asQueryString( Qgis::SensorThingsEntity parentEntityType, const QStringList &additionalOptions ) const
{
  if ( !isValid() )
    return QString();
 
  bool ok = false;
  // From the specifications, it SOMETIMES the plural form is used for the expansion query, and sometimes singular.
  // The choice depends on the cardinality of the relationship between the involved entities.
  const Qgis::RelationshipCardinality cardinality = QgsSensorThingsUtils::relationshipCardinality( parentEntityType, mChildEntity, ok );
  QString childEntityString;
  if ( !ok )
  {
    childEntityString = QgsSensorThingsUtils::entityToSetString( mChildEntity );
  }
  else
  {
    switch ( cardinality )
    {
      case Qgis::RelationshipCardinality::OneToOne:
      case Qgis::RelationshipCardinality::ManyToOne:
        // use singular strings, eg "Thing"
        childEntityString = qgsEnumValueToKey( mChildEntity );
        break;
 
      case Qgis::RelationshipCardinality::OneToMany:
      case Qgis::RelationshipCardinality::ManyToMany:
        // use plural strings, eg "Things"
        childEntityString = QgsSensorThingsUtils::entityToSetString( mChildEntity );
        break;
    }
  }
 
  QString res = u"$expand=%1"_s.arg( childEntityString );
 
  QStringList queryOptions;
  if ( !mOrderBy.isEmpty() )
    queryOptions.append( u"$orderby=%1%2"_s.arg( mOrderBy, mSortOrder == Qt::SortOrder::AscendingOrder ? QString() : u" desc"_s ) );
 
  if ( mLimit > -1 )
    queryOptions.append( u"$top=%1"_s.arg( mLimit ) );
 
  if ( !mFilter.isEmpty() )
    queryOptions.append( u"$filter=%1"_s.arg( mFilter ) );
 
  queryOptions.append( additionalOptions );
 
  if ( !queryOptions.isEmpty() )
    res.append( u"(%1)"_s.arg( queryOptions.join( ';' ) ) );
 
  return res;
}
 
bool QgsSensorThingsExpansionDefinition::operator==( const QgsSensorThingsExpansionDefinition &other ) const
{
  if ( mChildEntity == Qgis::SensorThingsEntity::Invalid )
    return other.mChildEntity == Qgis::SensorThingsEntity::Invalid;
 
  return mChildEntity == other.mChildEntity && mSortOrder == other.mSortOrder && mLimit == other.mLimit && mOrderBy == other.mOrderBy && mFilter == other.mFilter;
}
 
bool QgsSensorThingsExpansionDefinition::operator!=( const QgsSensorThingsExpansionDefinition &other ) const
{
  return !( *this == other );
}
 
QString QgsSensorThingsExpansionDefinition::orderBy() const
{
  return mOrderBy;
}
 
void QgsSensorThingsExpansionDefinition::setOrderBy( const QString &field )
{
  mOrderBy = field;
}
 
//
// QgsSensorThingsUtils
//
 
Qgis::SensorThingsEntity QgsSensorThingsUtils::stringToEntity( const QString &type )
{
  const QString trimmed = type.trimmed();
  if ( trimmed.compare( "Thing"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Thing;
  if ( trimmed.compare( "Location"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Location;
  if ( trimmed.compare( "HistoricalLocation"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::HistoricalLocation;
  if ( trimmed.compare( "Datastream"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Datastream;
  if ( trimmed.compare( "Sensor"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Sensor;
  if ( trimmed.compare( "ObservedProperty"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::ObservedProperty;
  if ( trimmed.compare( "Observation"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Observation;
  if ( trimmed.compare( "FeatureOfInterest"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::FeatureOfInterest;
  if ( trimmed.compare( "MultiDatastream"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::MultiDatastream;
  if ( trimmed.compare( "Feature"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Feature;
  if ( trimmed.compare( "FeatureType"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::FeatureType;
  if ( trimmed.compare( "Deployment"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Deployment;
  if ( trimmed.compare( "ObservingProcedure"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::ObservingProcedure;
  if ( trimmed.compare( "Sampling"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Sampling;
  if ( trimmed.compare( "SamplingProcedure"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::SamplingProcedure;
  if ( trimmed.compare( "Sampler"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Sampler;
  if ( trimmed.compare( "PreparationStep"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::PreparationStep;
  if ( trimmed.compare( "PreparationProcedure"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::PreparationProcedure;
  if ( trimmed.compare( "ThingRelation"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::ThingRelation;
  if ( trimmed.compare( "RelationRole"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::RelationRole;
  if ( trimmed.compare( "FeatureRelation"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::FeatureRelation;
  if ( trimmed.compare( "DatastreamRelation"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::DatastreamRelation;
  if ( trimmed.compare( "ObservationRelation"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::ObservationRelation;
 
  return Qgis::SensorThingsEntity::Invalid;
}
 
QString QgsSensorThingsUtils::displayString( Qgis::SensorThingsEntity type, bool plural )
{
  switch ( type )
  {
    case Qgis::SensorThingsEntity::Invalid:
      return QString();
    case Qgis::SensorThingsEntity::Thing:
      return plural ? QObject::tr( "Things" ) : QObject::tr( "Thing" );
    case Qgis::SensorThingsEntity::Location:
      return plural ? QObject::tr( "Locations" ) : QObject::tr( "Location" );
    case Qgis::SensorThingsEntity::HistoricalLocation:
      return plural ? QObject::tr( "Historical Locations" ) : QObject::tr( "Historical Location" );
    case Qgis::SensorThingsEntity::Datastream:
      return plural ? QObject::tr( "Datastreams" ) : QObject::tr( "Datastream" );
    case Qgis::SensorThingsEntity::Sensor:
      return plural ? QObject::tr( "Sensors" ) : QObject::tr( "Sensor" );
    case Qgis::SensorThingsEntity::ObservedProperty:
      return plural ? QObject::tr( "Observed Properties" ) : QObject::tr( "Observed Property" );
    case Qgis::SensorThingsEntity::Observation:
      return plural ? QObject::tr( "Observations" ) : QObject::tr( "Observation" );
    case Qgis::SensorThingsEntity::FeatureOfInterest:
      return plural ? QObject::tr( "Features of Interest" ) : QObject::tr( "Feature of Interest" );
    case Qgis::SensorThingsEntity::MultiDatastream:
      return plural ? QObject::tr( "MultiDatastreams" ) : QObject::tr( "MultiDatastream" );
    case Qgis::SensorThingsEntity::Feature:
      return plural ? QObject::tr( "Features" ) : QObject::tr( "Feature" );
    case Qgis::SensorThingsEntity::FeatureType:
      return plural ? QObject::tr( "Feature Types" ) : QObject::tr( "Feature Type" );
    case Qgis::SensorThingsEntity::Deployment:
      return plural ? QObject::tr( "Deployments" ) : QObject::tr( "Deployment" );
    case Qgis::SensorThingsEntity::ObservingProcedure:
      return plural ? QObject::tr( "Observing Procedures" ) : QObject::tr( "Observing Procedure" );
    case Qgis::SensorThingsEntity::Sampling:
      return plural ? QObject::tr( "Samplings" ) : QObject::tr( "Sampling" );
    case Qgis::SensorThingsEntity::SamplingProcedure:
      return plural ? QObject::tr( "Sampling Procedures" ) : QObject::tr( "Sampling Procedure" );
    case Qgis::SensorThingsEntity::Sampler:
      return plural ? QObject::tr( "Samplers" ) : QObject::tr( "Sampler" );
    case Qgis::SensorThingsEntity::PreparationStep:
      return plural ? QObject::tr( "Preparation Steps" ) : QObject::tr( "Preparation Step" );
    case Qgis::SensorThingsEntity::PreparationProcedure:
      return plural ? QObject::tr( "Preparation Procedures" ) : QObject::tr( "Preparation Procedure" );
    case Qgis::SensorThingsEntity::ThingRelation:
      return plural ? QObject::tr( "Thing Relations" ) : QObject::tr( "Thing Relation" );
    case Qgis::SensorThingsEntity::RelationRole:
      return plural ? QObject::tr( "Relation Roles" ) : QObject::tr( "Relation Role" );
    case Qgis::SensorThingsEntity::FeatureRelation:
      return plural ? QObject::tr( "Feature Relations" ) : QObject::tr( "Feature Relation" );
    case Qgis::SensorThingsEntity::DatastreamRelation:
      return plural ? QObject::tr( "Datastream Relations" ) : QObject::tr( "Datastream Relation" );
    case Qgis::SensorThingsEntity::ObservationRelation:
      return plural ? QObject::tr( "Observation Relations" ) : QObject::tr( "Observation Relation" );
  }
  BUILTIN_UNREACHABLE
}
 
Qgis::SensorThingsEntity QgsSensorThingsUtils::entitySetStringToEntity( const QString &type )
{
  const QString trimmed = type.trimmed();
  if ( trimmed.compare( "Things"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Thing;
  if ( trimmed.compare( "Locations"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Location;
  if ( trimmed.compare( "HistoricalLocations"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::HistoricalLocation;
  if ( trimmed.compare( "Datastreams"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Datastream;
  if ( trimmed.compare( "Sensors"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Sensor;
  if ( trimmed.compare( "ObservedProperties"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::ObservedProperty;
  if ( trimmed.compare( "Observations"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Observation;
  if ( trimmed.compare( "FeaturesOfInterest"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::FeatureOfInterest;
  if ( trimmed.compare( "MultiDatastreams"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::MultiDatastream;
  if ( trimmed.compare( "Features"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Feature;
  if ( trimmed.compare( "FeatureTypes"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::FeatureType;
  if ( trimmed.compare( "Deployments"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Deployment;
  if ( trimmed.compare( "ObservingProcedures"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::ObservingProcedure;
  if ( trimmed.compare( "Samplings"_L1, Qt::CaseInsensitive ) == 0 ) // confirm?
    return Qgis::SensorThingsEntity::Sampling;
  if ( trimmed.compare( "SamplingProcedures"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::SamplingProcedure;
  if ( trimmed.compare( "Samplers"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::Sampler;
  if ( trimmed.compare( "PreparationSteps"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::PreparationStep;
  if ( trimmed.compare( "PreparationProcedures"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::PreparationProcedure;
  if ( trimmed.compare( "ThingRelations"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::ThingRelation;
  if ( trimmed.compare( "RelationRoles"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::RelationRole;
  if ( trimmed.compare( "FeatureRelations"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::FeatureRelation;
  if ( trimmed.compare( "DatastreamRelations"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::DatastreamRelation;
  if ( trimmed.compare( "ObservationRelations"_L1, Qt::CaseInsensitive ) == 0 )
    return Qgis::SensorThingsEntity::ObservationRelation;
 
  return Qgis::SensorThingsEntity::Invalid;
}
 
QString QgsSensorThingsUtils::entityToSetString( Qgis::SensorThingsEntity type )
{
  switch ( type )
  {
    case Qgis::SensorThingsEntity::Invalid:
      return QString();
    case Qgis::SensorThingsEntity::Thing:
      return u"Things"_s;
    case Qgis::SensorThingsEntity::Location:
      return u"Locations"_s;
    case Qgis::SensorThingsEntity::HistoricalLocation:
      return u"HistoricalLocations"_s;
    case Qgis::SensorThingsEntity::Datastream:
      return u"Datastreams"_s;
    case Qgis::SensorThingsEntity::Sensor:
      return u"Sensors"_s;
    case Qgis::SensorThingsEntity::ObservedProperty:
      return u"ObservedProperties"_s;
    case Qgis::SensorThingsEntity::Observation:
      return u"Observations"_s;
    case Qgis::SensorThingsEntity::FeatureOfInterest:
      return u"FeaturesOfInterest"_s;
    case Qgis::SensorThingsEntity::MultiDatastream:
      return u"MultiDatastreams"_s;
    case Qgis::SensorThingsEntity::Feature:
      return u"Features"_s;
    case Qgis::SensorThingsEntity::FeatureType:
      return u"FeatureTypes"_s;
    case Qgis::SensorThingsEntity::Deployment:
      return u"Deployments"_s;
    case Qgis::SensorThingsEntity::ObservingProcedure:
      return u"ObservingProcedures"_s;
    case Qgis::SensorThingsEntity::Sampling:
      return u"Samplings"_s; // confirm?
    case Qgis::SensorThingsEntity::SamplingProcedure:
      return u"SamplingProcedures"_s;
    case Qgis::SensorThingsEntity::Sampler:
      return u"Samplers"_s;
    case Qgis::SensorThingsEntity::PreparationStep:
      return u"PreparationSteps"_s;
    case Qgis::SensorThingsEntity::PreparationProcedure:
      return u"PreparationProcedures"_s;
    case Qgis::SensorThingsEntity::ThingRelation:
      return u"ThingRelations"_s;
    case Qgis::SensorThingsEntity::RelationRole:
      return u"RelationRoles"_s;
    case Qgis::SensorThingsEntity::FeatureRelation:
      return u"FeatureRelations"_s;
    case Qgis::SensorThingsEntity::DatastreamRelation:
      return u"DatastreamRelations"_s;
    case Qgis::SensorThingsEntity::ObservationRelation:
      return u"ObservationRelations"_s;
  }
  BUILTIN_UNREACHABLE
}
 
QStringList QgsSensorThingsUtils::propertiesForEntityType( Qgis::SensorThingsEntity type )
{
  switch ( type )
  {
    case Qgis::SensorThingsEntity::Invalid:
      return {};
 
    case Qgis::SensorThingsEntity::Thing:
      // https://docs.ogc.org/is/18-088/18-088.html#thing
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::Location:
      // https://docs.ogc.org/is/18-088/18-088.html#location
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::HistoricalLocation:
      // https://docs.ogc.org/is/18-088/18-088.html#historicallocation
      return {
        u"id"_s,
        u"selfLink"_s,
        u"time"_s,
      };
 
    case Qgis::SensorThingsEntity::Datastream:
      // https://docs.ogc.org/is/18-088/18-088.html#datastream
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"description"_s,
        u"unitOfMeasurement"_s,
        u"observationType"_s,
        u"properties"_s,
        u"phenomenonTime"_s,
        u"resultTime"_s,
      };
 
    case Qgis::SensorThingsEntity::Sensor:
      // https://docs.ogc.org/is/18-088/18-088.html#sensor
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"description"_s,
        u"metadata"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::ObservedProperty:
      // https://docs.ogc.org/is/18-088/18-088.html#observedproperty
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"definition"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::Observation:
      // https://docs.ogc.org/is/18-088/18-088.html#observation
      return {
        u"id"_s,
        u"selfLink"_s,
        u"phenomenonTime"_s,
        u"result"_s,
        u"resultTime"_s,
        u"resultQuality"_s,
        u"validTime"_s,
        u"parameters"_s,
      };
 
    case Qgis::SensorThingsEntity::FeatureOfInterest:
      // https://docs.ogc.org/is/18-088/18-088.html#featureofinterest
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::Feature:
      // TODO -- link to final 2.0 definition
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::FeatureType:
      // TODO -- link to final 2.0 definition
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::MultiDatastream:
      // https://docs.ogc.org/is/18-088/18-088.html#multidatastream-extension
      return {
        u"id"_s,
        u"selfLink"_s,
        u"name"_s,
        u"description"_s,
        u"unitOfMeasurements"_s,
        u"observationType"_s,
        u"multiObservationDataTypes"_s,
        u"properties"_s,
        u"phenomenonTime"_s,
        u"resultTime"_s,
      };
 
    case Qgis::SensorThingsEntity::Deployment:
      // https://hylkevds.github.io/24-046/24-046.html#deployment
      return {
        u"id"_s,
        u"name"_s,
        u"description"_s,
        u"properties"_s,
        u"encodingType"_s,
        u"position"_s,
        u"time"_s,
      };
 
    case Qgis::SensorThingsEntity::ObservingProcedure:
      // https://hylkevds.github.io/24-046/24-046.html#observingprocedure
      return {
        u"id"_s,
        u"name"_s,
        u"definition"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::Sampling:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      return {
        u"id"_s,
        u"name"_s,
        u"definition"_s,
        u"description"_s,
        u"encodingType"_s,
        u"properties"_s,
        u"time"_s,
      };
 
    case Qgis::SensorThingsEntity::SamplingProcedure:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      return {
        u"id"_s,
        u"name"_s,
        u"definition"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::Sampler:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      return {
        u"id"_s,
        u"name"_s,
        u"definition"_s,
        u"description"_s,
        u"properties"_s,
        u"samplerType"_s,
      };
 
    case Qgis::SensorThingsEntity::PreparationStep:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      return {
        u"id"_s,
        u"name"_s,
        u"definition"_s,
        u"description"_s,
        u"properties"_s,
        u"time"_s,
      };
 
    case Qgis::SensorThingsEntity::PreparationProcedure:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      return {
        u"id"_s,
        u"name"_s,
        u"definition"_s,
        u"description"_s,
        u"properties"_s,
      };
 
    case Qgis::SensorThingsEntity::ThingRelation:
      // https://hylkevds.github.io/24-046/24-046.html#relations-extension
      return { u"id"_s, u"externalTarget"_s };
 
    case Qgis::SensorThingsEntity::DatastreamRelation:
      // https://hylkevds.github.io/24-046/24-046.html#relations-extension
      return { u"id"_s, u"externalTarget"_s };
 
    case Qgis::SensorThingsEntity::ObservationRelation:
      // https://hylkevds.github.io/24-046/24-046.html#relations-extension
      return { u"id"_s, u"externalTarget"_s };
 
    case Qgis::SensorThingsEntity::FeatureRelation:
      // https://hylkevds.github.io/24-046/24-046.html#relations-extension
      return { u"id"_s, u"externalTarget"_s };
 
    case Qgis::SensorThingsEntity::RelationRole:
      // https://hylkevds.github.io/24-046/24-046.html#relations-extension
      return {
        u"id"_s,
        u"name"_s,
        u"definition"_s,
        u"inverseName"_s,
        u"inverseDefinition"_s,
        u"description"_s,
        u"properties"_s,
      };
  }
 
  return {};
}
 
QgsFields QgsSensorThingsUtils::fieldsForEntityType( Qgis::SensorThingsEntity type, bool includeRangeFieldProxies )
{
  QgsFields fields;
 
  // common fields: https://docs.ogc.org/is/18-088/18-088.html#common-control-information
  fields.append( QgsField( u"id"_s, QMetaType::Type::QString ) );
  fields.append( QgsField( u"selfLink"_s, QMetaType::Type::QString ) );
 
  switch ( type )
  {
    case Qgis::SensorThingsEntity::Invalid:
      break;
 
    case Qgis::SensorThingsEntity::Thing:
      // https://docs.ogc.org/is/18-088/18-088.html#thing
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::Location:
      // https://docs.ogc.org/is/18-088/18-088.html#location
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::HistoricalLocation:
      // https://docs.ogc.org/is/18-088/18-088.html#historicallocation
      fields.append( QgsField( u"time"_s, QMetaType::Type::QDateTime ) );
      break;
 
    case Qgis::SensorThingsEntity::Datastream:
      // https://docs.ogc.org/is/18-088/18-088.html#datastream
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"unitOfMeasurement"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      fields.append( QgsField( u"observationType"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      if ( includeRangeFieldProxies )
      {
        fields.append( QgsField( u"phenomenonTimeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"phenomenonTimeEnd"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"resultTimeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"resultTimeEnd"_s, QMetaType::Type::QDateTime ) );
      }
      break;
 
    case Qgis::SensorThingsEntity::Sensor:
      // https://docs.ogc.org/is/18-088/18-088.html#sensor
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"metadata"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::ObservedProperty:
      // https://docs.ogc.org/is/18-088/18-088.html#observedproperty
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"definition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::Observation:
      // https://docs.ogc.org/is/18-088/18-088.html#observation
      if ( includeRangeFieldProxies )
      {
        fields.append( QgsField( u"phenomenonTimeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"phenomenonTimeEnd"_s, QMetaType::Type::QDateTime ) );
      }
 
      // TODO -- handle type correctly
      fields.append( QgsField( u"result"_s, QMetaType::Type::QString ) );
 
      fields.append( QgsField( u"resultTime"_s, QMetaType::Type::QDateTime ) );
      fields.append( QgsField( u"resultQuality"_s, QMetaType::Type::QStringList, QString(), 0, 0, QString(), QMetaType::Type::QString ) );
      if ( includeRangeFieldProxies )
      {
        fields.append( QgsField( u"validTimeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"validTimeEnd"_s, QMetaType::Type::QDateTime ) );
      }
      fields.append( QgsField( u"parameters"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::FeatureOfInterest:
      // https://docs.ogc.org/is/18-088/18-088.html#featureofinterest
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::Feature:
      // TODO -- insert link to final 2.0 spec
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::FeatureType:
      // TODO -- insert link to final 2.0 spec
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::MultiDatastream:
      // https://docs.ogc.org/is/18-088/18-088.html#multidatastream-extension
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"unitOfMeasurements"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      fields.append( QgsField( u"observationType"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"multiObservationDataTypes"_s, QMetaType::Type::QStringList, QString(), 0, 0, QString(), QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      if ( includeRangeFieldProxies )
      {
        fields.append( QgsField( u"phenomenonTimeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"phenomenonTimeEnd"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"resultTimeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"resultTimeEnd"_s, QMetaType::Type::QDateTime ) );
      }
      break;
 
    case Qgis::SensorThingsEntity::Deployment:
      // https://hylkevds.github.io/24-046/24-046.html#deployment
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      if ( includeRangeFieldProxies )
      {
        fields.append( QgsField( u"timeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"timeEnd"_s, QMetaType::Type::QDateTime ) );
      }
      break;
 
    case Qgis::SensorThingsEntity::ObservingProcedure:
      // https://hylkevds.github.io/24-046/24-046.html#observingprocedure
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"definition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::Sampling:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"definition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      if ( includeRangeFieldProxies )
      {
        fields.append( QgsField( u"timeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"timeEnd"_s, QMetaType::Type::QDateTime ) );
      }
      break;
 
    case Qgis::SensorThingsEntity::SamplingProcedure:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"definition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::Sampler:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"definition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      fields.append( QgsField( u"samplerType"_s, QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::PreparationStep:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"definition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      if ( includeRangeFieldProxies )
      {
        fields.append( QgsField( u"timeStart"_s, QMetaType::Type::QDateTime ) );
        fields.append( QgsField( u"timeEnd"_s, QMetaType::Type::QDateTime ) );
      }
      break;
 
    case Qgis::SensorThingsEntity::PreparationProcedure:
      // https://hylkevds.github.io/24-046/24-046.html#sampling-extension
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"definition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::DatastreamRelation:
      // https://hylkevds.github.io/24-046/24-046.html#relations-extension
      fields.append( QgsField( u"externalTarget"_s, QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::ThingRelation:
      // https://hylkevds.github.io/24-046/24-046.html#relations-extension
      fields.append( QgsField( u"externalTarget"_s, QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::RelationRole:
      // https://hylkevds.github.io/24-046/24-046.html#relations-extension
      fields.append( QgsField( u"name"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"definition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"inverseName"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"inverseDefinition"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"description"_s, QMetaType::Type::QString ) );
      fields.append( QgsField( u"properties"_s, QMetaType::Type::QVariantMap, u"json"_s, 0, 0, QString(), QMetaType::Type::QString ) );
      break;
 
 
    case Qgis::SensorThingsEntity::ObservationRelation:
      // https://hylkevds.github.io/24-046/24-046.html#_2d386fc6-41ac-7af3-6b6b-4590cbcd9087
      fields.append( QgsField( u"externalTarget"_s, QMetaType::Type::QString ) );
      break;
 
    case Qgis::SensorThingsEntity::FeatureRelation:
      // https://hylkevds.github.io/24-046/24-046.html#_f990126f-f23a-4a7c-e602-29ca553ce612
      fields.append( QgsField( u"externalTarget"_s, QMetaType::Type::QString ) );
      break;
  }
 
  return fields;
}
 
QgsFields QgsSensorThingsUtils::fieldsForExpandedEntityType( Qgis::SensorThingsEntity baseType, const QList<Qgis::SensorThingsEntity> &expandedTypes )
{
  if ( expandedTypes.empty() )
    return fieldsForEntityType( baseType );
 
  QgsFields fields = fieldsForEntityType( baseType );
  QString path;
  for ( const Qgis::SensorThingsEntity expandedType : expandedTypes )
  {
    path = ( path.isEmpty() ? QString() : ( path + '_' ) ) + qgsEnumValueToKey( expandedType );
    const QgsFields expandedFields = fieldsForEntityType( expandedType );
    for ( const QgsField &expandedField : expandedFields )
    {
      QgsField renamedExpandedField = expandedField;
      renamedExpandedField.setName( u"%1_%2"_s.arg( path, expandedField.name() ) );
      fields.append( renamedExpandedField );
    }
  }
  return fields;
}
 
QString QgsSensorThingsUtils::geometryFieldForEntityType( Qgis::SensorThingsEntity type )
{
  switch ( type )
  {
    case Qgis::SensorThingsEntity::Invalid:
    case Qgis::SensorThingsEntity::Thing:
    case Qgis::SensorThingsEntity::HistoricalLocation:
    case Qgis::SensorThingsEntity::Sensor:
    case Qgis::SensorThingsEntity::Observation:
    case Qgis::SensorThingsEntity::ObservedProperty:
    case Qgis::SensorThingsEntity::FeatureType:
    case Qgis::SensorThingsEntity::ObservingProcedure:
    case Qgis::SensorThingsEntity::Sampler:
    case Qgis::SensorThingsEntity::SamplingProcedure:
    case Qgis::SensorThingsEntity::PreparationStep:
    case Qgis::SensorThingsEntity::PreparationProcedure:
    case Qgis::SensorThingsEntity::DatastreamRelation:
    case Qgis::SensorThingsEntity::ThingRelation:
    case Qgis::SensorThingsEntity::RelationRole:
    case Qgis::SensorThingsEntity::ObservationRelation:
    case Qgis::SensorThingsEntity::FeatureRelation:
      return QString();
 
    case Qgis::SensorThingsEntity::Location:
    case Qgis::SensorThingsEntity::Sampling:
      return u"location"_s;
 
    case Qgis::SensorThingsEntity::FeatureOfInterest:
    case Qgis::SensorThingsEntity::Feature:
      return u"feature"_s;
 
    case Qgis::SensorThingsEntity::Datastream:
    case Qgis::SensorThingsEntity::MultiDatastream:
      return u"observedArea"_s;
 
    case Qgis::SensorThingsEntity::Deployment:
      return u"position"_s;
  }
  BUILTIN_UNREACHABLE
}
 
bool QgsSensorThingsUtils::entityTypeHasGeometry( Qgis::SensorThingsEntity type )
{
  switch ( type )
  {
    case Qgis::SensorThingsEntity::Invalid:
    case Qgis::SensorThingsEntity::Thing:
    case Qgis::SensorThingsEntity::HistoricalLocation:
    case Qgis::SensorThingsEntity::Sensor:
    case Qgis::SensorThingsEntity::Observation:
    case Qgis::SensorThingsEntity::ObservedProperty:
    case Qgis::SensorThingsEntity::FeatureType:
    case Qgis::SensorThingsEntity::ObservingProcedure:
    case Qgis::SensorThingsEntity::Sampler:
    case Qgis::SensorThingsEntity::SamplingProcedure:
    case Qgis::SensorThingsEntity::PreparationStep:
    case Qgis::SensorThingsEntity::PreparationProcedure:
    case Qgis::SensorThingsEntity::DatastreamRelation:
    case Qgis::SensorThingsEntity::ThingRelation:
    case Qgis::SensorThingsEntity::RelationRole:
    case Qgis::SensorThingsEntity::ObservationRelation:
    case Qgis::SensorThingsEntity::FeatureRelation:
      return false;
 
    case Qgis::SensorThingsEntity::Datastream:
    case Qgis::SensorThingsEntity::Location:
    case Qgis::SensorThingsEntity::FeatureOfInterest:
    case Qgis::SensorThingsEntity::Feature:
    case Qgis::SensorThingsEntity::MultiDatastream:
    case Qgis::SensorThingsEntity::Deployment:
    case Qgis::SensorThingsEntity::Sampling:
      return true;
  }
  BUILTIN_UNREACHABLE
}
 
Qgis::GeometryType QgsSensorThingsUtils::geometryTypeForEntity( Qgis::SensorThingsEntity type )
{
  switch ( type )
  {
    case Qgis::SensorThingsEntity::Invalid:
    case Qgis::SensorThingsEntity::Thing:
    case Qgis::SensorThingsEntity::HistoricalLocation:
    case Qgis::SensorThingsEntity::Sensor:
    case Qgis::SensorThingsEntity::Observation:
    case Qgis::SensorThingsEntity::ObservedProperty:
    case Qgis::SensorThingsEntity::FeatureType:
    case Qgis::SensorThingsEntity::ObservingProcedure:
    case Qgis::SensorThingsEntity::Sampler:
    case Qgis::SensorThingsEntity::SamplingProcedure:
    case Qgis::SensorThingsEntity::PreparationStep:
    case Qgis::SensorThingsEntity::PreparationProcedure:
    case Qgis::SensorThingsEntity::DatastreamRelation:
    case Qgis::SensorThingsEntity::ThingRelation:
    case Qgis::SensorThingsEntity::RelationRole:
    case Qgis::SensorThingsEntity::ObservationRelation:
    case Qgis::SensorThingsEntity::FeatureRelation:
      return Qgis::GeometryType::Null;
 
    case Qgis::SensorThingsEntity::Datastream:
    case Qgis::SensorThingsEntity::Location:
    case Qgis::SensorThingsEntity::FeatureOfInterest:
    case Qgis::SensorThingsEntity::Feature:
    case Qgis::SensorThingsEntity::MultiDatastream:
    case Qgis::SensorThingsEntity::Deployment:
    case Qgis::SensorThingsEntity::Sampling:
      return Qgis::GeometryType::Unknown;
  }
  BUILTIN_UNREACHABLE
}
 
QString QgsSensorThingsUtils::filterForWkbType( Qgis::SensorThingsEntity entityType, Qgis::WkbType wkbType )
{
  QString geometryTypeString;
  switch ( QgsWkbTypes::geometryType( wkbType ) )
  {
    case Qgis::GeometryType::Point:
      geometryTypeString = u"Point"_s;
      break;
    case Qgis::GeometryType::Polygon:
      geometryTypeString = u"Polygon"_s;
      break;
    case Qgis::GeometryType::Line:
      geometryTypeString = u"LineString"_s;
      break;
 
    case Qgis::GeometryType::Unknown:
    case Qgis::GeometryType::Null:
      return QString();
  }
 
  const QString filterTarget = geometryFieldForEntityType( entityType );
  if ( filterTarget.isEmpty() )
    return QString();
 
  return u"%1/type eq '%2' or %1/geometry/type eq '%2'"_s.arg( filterTarget, geometryTypeString );
}
 
QString QgsSensorThingsUtils::filterForExtent( const QString &geometryField, const QgsRectangle &extent )
{
  // TODO -- confirm using 'geography' is always correct here
  return ( extent.isNull() || geometryField.isEmpty() ) ? QString() : u"geo.intersects(%1, geography'%2')"_s.arg( geometryField, extent.asWktPolygon() );
}
 
QString QgsSensorThingsUtils::combineFilters( const QStringList &filters )
{
  QStringList nonEmptyFilters;
  for ( const QString &filter : filters )
  {
    if ( !filter.isEmpty() )
      nonEmptyFilters.append( filter );
  }
  if ( nonEmptyFilters.empty() )
    return QString();
  if ( nonEmptyFilters.size() == 1 )
    return nonEmptyFilters.at( 0 );
 
  return u"("_s + nonEmptyFilters.join( ") and ("_L1 ) + u")"_s;
}
 
QgsSensorThingsUtils::ServiceCapabilities QgsSensorThingsUtils::determineServiceCapabilities( const QString &uri, QgsFeedback *feedback, const QString &authCfg )
{
  QgsSensorThingsUtils::ServiceCapabilities res;
  QNetworkRequest request = QNetworkRequest( QUrl( uri ) );
  QgsSetRequestInitiatorClass( request, u"QgsSensorThingsUtils"_s )
 
    QgsBlockingNetworkRequest networkRequest;
  networkRequest.setAuthCfg( authCfg );
 
  switch ( networkRequest.get( request, false, feedback ) )
  {
    case QgsBlockingNetworkRequest::NoError:
      break;
 
    case QgsBlockingNetworkRequest::NetworkError:
    case QgsBlockingNetworkRequest::TimeoutError:
    case QgsBlockingNetworkRequest::ServerExceptionError:
      QgsDebugError( u"Connection failed: %1"_s.arg( networkRequest.errorMessage() ) );
      return res;
  }
 
  const QgsNetworkReplyContent content = networkRequest.reply();
  try
  {
    auto rootContent = nlohmann::json::parse( content.content().toStdString() );
    if ( rootContent.contains( "serverSettings" ) && rootContent["serverSettings"].contains( "conformance" ) )
    {
      for ( const auto &valueJson : rootContent["serverSettings"]["conformance"] )
      {
        const QString conformance = QString::fromStdString( valueJson.get<std::string>() );
        const thread_local QRegularExpression sDataModelRx( u".*/datamodel\\b"_s );
        if ( sDataModelRx.match( conformance ).hasMatch() )
        {
          // extract version from datamodel value
          const thread_local QRegularExpression sVersionRx( u"\\d+\\.\\d+"_s );
          const QRegularExpressionMatch versionMatch = sVersionRx.match( conformance );
          if ( versionMatch.hasMatch() )
          {
            const QString versionString = versionMatch.captured( 0 );
            bool ok = false;
            const double version = versionString.toDouble( &ok );
            if ( ok )
            {
              if ( version < 2.0 )
              {
                res.version = Qgis::SensorThingsVersion::Version1_1;
              }
              else
              {
                res.version = Qgis::SensorThingsVersion::Version2_0;
              }
            }
          }
        }
 
        const thread_local QRegularExpression sMultiDataStreamRx( u".*/req/multi-datastream\\b"_s );
        const thread_local QRegularExpression sSensingOmRx( u".*/req/sensing-extension-om\\b"_s );
        const thread_local QRegularExpression sSensingRelationsRx( u".*/req/sensing-extension-relations\\b"_s );
        const thread_local QRegularExpression sSensingSamplingRx( u".*/req/sensing-extension-sampling\\b"_s );
        if ( sMultiDataStreamRx.match( conformance ).hasMatch() )
          res.availableExtensions.setFlag( Qgis::SensorThingsExtension::MultiDatastream );
        else if ( sSensingOmRx.match( conformance ).hasMatch() )
          res.availableExtensions.setFlag( Qgis::SensorThingsExtension::SensingExtensionObservationsMeasurements );
        else if ( sSensingRelationsRx.match( conformance ).hasMatch() )
          res.availableExtensions.setFlag( Qgis::SensorThingsExtension::SensingExtensionRelations );
        else if ( sSensingSamplingRx.match( conformance ).hasMatch() )
          res.availableExtensions.setFlag( Qgis::SensorThingsExtension::SensingExtensionSampling );
      }
    }
    if ( rootContent.contains( "value" ) )
    {
      for ( const auto &valueJson : rootContent["value"] )
      {
        if ( valueJson.contains( "name" ) && valueJson.contains( "url" ) )
        {
          const QString name = QString::fromStdString( valueJson["name"].get<std::string>() );
          const Qgis::SensorThingsEntity entityType = QgsSensorThingsUtils::entitySetStringToEntity( name );
          if ( entityType != Qgis::SensorThingsEntity::Invalid )
          {
            res.availableEntities.insert( entityType );
          }
        }
      }
    }
  }
  catch ( const nlohmann::json::parse_error &ex )
  {
    QgsDebugError( u"Error parsing response: %1"_s.arg( ex.what() ) );
    return {};
  }
  return res;
}
 
QList<Qgis::GeometryType> QgsSensorThingsUtils::availableGeometryTypes( const QString &uri, Qgis::SensorThingsEntity type, QgsFeedback *feedback, const QString &authCfg )
{
  QNetworkRequest request = QNetworkRequest( QUrl( uri ) );
  QgsSetRequestInitiatorClass( request, u"QgsSensorThingsUtils"_s )
 
    QgsBlockingNetworkRequest networkRequest;
  networkRequest.setAuthCfg( authCfg );
 
  switch ( networkRequest.get( request ) )
  {
    case QgsBlockingNetworkRequest::NoError:
      break;
 
    case QgsBlockingNetworkRequest::NetworkError:
    case QgsBlockingNetworkRequest::TimeoutError:
    case QgsBlockingNetworkRequest::ServerExceptionError:
      QgsDebugError( u"Connection failed: %1"_s.arg( networkRequest.errorMessage() ) );
      return {};
  }
 
  QString entityBaseUri;
  const QgsNetworkReplyContent content = networkRequest.reply();
  try
  {
    auto rootContent = nlohmann::json::parse( content.content().toStdString() );
    if ( !rootContent.contains( "value" ) )
    {
      QgsDebugError( u"No 'value' array in response"_s );
      return {};
    }
 
    bool foundMatchingEntity = false;
    for ( const auto &valueJson : rootContent["value"] )
    {
      if ( valueJson.contains( "name" ) && valueJson.contains( "url" ) )
      {
        const QString name = QString::fromStdString( valueJson["name"].get<std::string>() );
        Qgis::SensorThingsEntity entityType = QgsSensorThingsUtils::entitySetStringToEntity( name );
        if ( entityType == type )
        {
          const QString url = QString::fromStdString( valueJson["url"].get<std::string>() );
          if ( !url.isEmpty() )
          {
            foundMatchingEntity = true;
            entityBaseUri = url;
            break;
          }
        }
      }
    }
 
    if ( !foundMatchingEntity )
    {
      QgsDebugError( u"Could not find url for %1"_s.arg( qgsEnumValueToKey( type ) ) );
      return {};
    }
  }
  catch ( const nlohmann::json::parse_error &ex )
  {
    QgsDebugError( u"Error parsing response: %1"_s.arg( ex.what() ) );
    return {};
  }
 
  auto getCountForType = [entityBaseUri, type, authCfg, feedback]( Qgis::GeometryType geometryType ) -> long long {
    // return no features, just the total count
    QString countUri = u"%1?$top=0&$count=true"_s.arg( entityBaseUri );
    Qgis::WkbType wkbType = geometryType == Qgis::GeometryType::Polygon ? Qgis::WkbType::Polygon : ( geometryType == Qgis::GeometryType::Line ? Qgis::WkbType::LineString : Qgis::WkbType::Point );
    const QString typeFilter = QgsSensorThingsUtils::filterForWkbType( type, wkbType );
    if ( !typeFilter.isEmpty() )
      countUri += u"&$filter="_s + typeFilter;
 
    const QUrl url( countUri );
 
    QNetworkRequest request( url );
    QgsSetRequestInitiatorClass( request, u"QgsSensorThingsSharedData"_s );
 
    QgsBlockingNetworkRequest networkRequest;
    networkRequest.setAuthCfg( authCfg );
    const QgsBlockingNetworkRequest::ErrorCode error = networkRequest.get( request, false, feedback );
 
    if ( feedback && feedback->isCanceled() )
      return -1;
 
    // Handle network errors
    if ( error != QgsBlockingNetworkRequest::NoError )
    {
      QgsDebugError( u"Network error: %1"_s.arg( networkRequest.errorMessage() ) );
      return -1;
    }
    else
    {
      const QgsNetworkReplyContent content = networkRequest.reply();
      try
      {
        auto rootContent = nlohmann::json::parse( content.content().toStdString() );
        if ( rootContent.contains( "@iot.count" ) )
        {
          return rootContent["@iot.count"].get<long long>();
        }
        else if ( rootContent.contains( "@count" ) )
        {
          return rootContent["@count"].get<long long>();
        }
 
        QgsDebugError( u"No 'count' value in response"_s );
        return -1;
      }
      catch ( const nlohmann::json::parse_error &ex )
      {
        QgsDebugError( u"Error parsing response: %1"_s.arg( ex.what() ) );
        return -1;
      }
    }
  };
 
  QList<Qgis::GeometryType> types;
  for ( Qgis::GeometryType geometryType : { Qgis::GeometryType::Point, Qgis::GeometryType::Line, Qgis::GeometryType::Polygon } )
  {
    const long long matchCount = getCountForType( geometryType );
    if ( matchCount < 0 )
      return {};
    else if ( matchCount > 0 )
      types.append( geometryType );
  }
  return types;
}
 
QList<Qgis::SensorThingsEntity> QgsSensorThingsUtils::expandableTargets( Qgis::SensorThingsEntity type )
{
  // note that we are restricting these choices so that the geometry enabled entity type MUST be the base type
 
  // NOLINTBEGIN(bugprone-branch-clone)
  switch ( type )
  {
    case Qgis::SensorThingsEntity::Invalid:
      return {};
 
    case Qgis::SensorThingsEntity::Thing:
      return {
        Qgis::SensorThingsEntity::HistoricalLocation,
        Qgis::SensorThingsEntity::Datastream,
        Qgis::SensorThingsEntity::MultiDatastream,
      };
 
    case Qgis::SensorThingsEntity::Location:
      return {
        Qgis::SensorThingsEntity::Thing,
        Qgis::SensorThingsEntity::HistoricalLocation,
      };
 
    case Qgis::SensorThingsEntity::HistoricalLocation:
      return { Qgis::SensorThingsEntity::Thing };
 
    case Qgis::SensorThingsEntity::Datastream:
      return { Qgis::SensorThingsEntity::Thing, Qgis::SensorThingsEntity::Sensor, Qgis::SensorThingsEntity::ObservedProperty, Qgis::SensorThingsEntity::Observation };
 
    case Qgis::SensorThingsEntity::Sensor:
      return {
        Qgis::SensorThingsEntity::Datastream,
        Qgis::SensorThingsEntity::MultiDatastream,
      };
 
    case Qgis::SensorThingsEntity::ObservedProperty:
      return { Qgis::SensorThingsEntity::Datastream, Qgis::SensorThingsEntity::MultiDatastream };
 
    case Qgis::SensorThingsEntity::Observation:
      return { Qgis::SensorThingsEntity::Datastream, Qgis::SensorThingsEntity::MultiDatastream };
 
    case Qgis::SensorThingsEntity::FeatureOfInterest:
      return { Qgis::SensorThingsEntity::Observation };
 
    case Qgis::SensorThingsEntity::Feature:
      return { Qgis::SensorThingsEntity::Observation, Qgis::SensorThingsEntity::Datastream, Qgis::SensorThingsEntity::FeatureType, Qgis::SensorThingsEntity::PreparationStep, Qgis::SensorThingsEntity::Sampling, Qgis::SensorThingsEntity::FeatureRelation };
 
    case Qgis::SensorThingsEntity::FeatureType:
      return {};
 
    case Qgis::SensorThingsEntity::MultiDatastream:
      return { Qgis::SensorThingsEntity::Thing, Qgis::SensorThingsEntity::Sensor, Qgis::SensorThingsEntity::ObservedProperty, Qgis::SensorThingsEntity::Observation };
 
    case Qgis::SensorThingsEntity::Deployment:
      return { Qgis::SensorThingsEntity::Thing, Qgis::SensorThingsEntity::Datastream, Qgis::SensorThingsEntity::Sensor };
 
    case Qgis::SensorThingsEntity::ObservingProcedure:
      return { Qgis::SensorThingsEntity::Sensor, Qgis::SensorThingsEntity::ObservedProperty, Qgis::SensorThingsEntity::Datastream };
 
    case Qgis::SensorThingsEntity::Sampling:
      return { Qgis::SensorThingsEntity::Thing, Qgis::SensorThingsEntity::SamplingProcedure, Qgis::SensorThingsEntity::Sampler, Qgis::SensorThingsEntity::Feature };
 
    case Qgis::SensorThingsEntity::Sampler:
      return { Qgis::SensorThingsEntity::SamplingProcedure };
 
    case Qgis::SensorThingsEntity::SamplingProcedure:
      return { Qgis::SensorThingsEntity::Sampler };
 
    case Qgis::SensorThingsEntity::PreparationStep:
      return { Qgis::SensorThingsEntity::PreparationProcedure };
 
    case Qgis::SensorThingsEntity::PreparationProcedure:
      return { Qgis::SensorThingsEntity::PreparationStep };
 
    case Qgis::SensorThingsEntity::DatastreamRelation:
      return { Qgis::SensorThingsEntity::Datastream, Qgis::SensorThingsEntity::RelationRole };
 
    case Qgis::SensorThingsEntity::ThingRelation:
      return { Qgis::SensorThingsEntity::Thing, Qgis::SensorThingsEntity::RelationRole };
 
    case Qgis::SensorThingsEntity::RelationRole:
      return { Qgis::SensorThingsEntity::ThingRelation, Qgis::SensorThingsEntity::DatastreamRelation, Qgis::SensorThingsEntity::ObservationRelation, Qgis::SensorThingsEntity::FeatureRelation };
 
    case Qgis::SensorThingsEntity::ObservationRelation:
      return { Qgis::SensorThingsEntity::Observation, Qgis::SensorThingsEntity::RelationRole };
 
    case Qgis::SensorThingsEntity::FeatureRelation:
      return { Qgis::SensorThingsEntity::Feature, Qgis::SensorThingsEntity::RelationRole };
  }
  // NOLINTEND(bugprone-branch-clone)
 
  BUILTIN_UNREACHABLE
}
 
Qgis::RelationshipCardinality QgsSensorThingsUtils::relationshipCardinality( Qgis::SensorThingsEntity baseType, Qgis::SensorThingsEntity relatedType, bool &valid )
{
  valid = true;
  switch ( baseType )
  {
    case Qgis::SensorThingsEntity::Invalid:
      break;
 
    case Qgis::SensorThingsEntity::Thing:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Location:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::ThingRelation:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
      break;
    }
    case Qgis::SensorThingsEntity::Location:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::HistoricalLocation:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
      break;
    }
    case Qgis::SensorThingsEntity::HistoricalLocation:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Location:
          // The SensorThings specification MAY be wrong here. There's an inconsistency between
          // the inheritance graph which shows HistoricalLocation linking to "location", when
          // the text description describes the relationship as linking to "locationS".
          // We assume the text description is correct and the graph is wrong, as the reverse
          // relationship between Location and HistoricalLocation is many-to-many.
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Thing:
          return Qgis::RelationshipCardinality::OneToOne;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::Datastream:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::ObservingProcedure:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::DatastreamRelation:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::Deployment:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::Sensor:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Deployment:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::ObservingProcedure:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::ObservedProperty:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Datastream:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::ObservingProcedure:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
      break;
    }
 
    case Qgis::SensorThingsEntity::Observation:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::ObservationRelation:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Feature:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
      break;
    }
 
    case Qgis::SensorThingsEntity::FeatureOfInterest:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Observation:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::Feature:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::FeatureRelation:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Sampling:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::FeatureType:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Feature:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::MultiDatastream:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Sensor:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::ObservedProperty:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Observation:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
      break;
    }
 
    case Qgis::SensorThingsEntity::Deployment:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::Thing:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::Datastream:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::ObservingProcedure:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Datastream:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::Sampler:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Sampling:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::SamplingProcedure:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::Sampling:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sampler:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::Feature:
          return Qgis::RelationshipCardinality::ManyToMany;
 
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::SamplingProcedure:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::Sampler:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::PreparationProcedure:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::PreparationStep:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::PreparationStep:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::Feature:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::ThingRelation:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::RelationRole:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::FeatureRelation:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::RelationRole:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::DatastreamRelation:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::RelationRole:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::ObservationRelation:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::RelationRole:
          return Qgis::RelationshipCardinality::ManyToOne;
 
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::Sampler:
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          break;
      }
 
      break;
    }
 
    case Qgis::SensorThingsEntity::RelationRole:
    {
      switch ( relatedType )
      {
        case Qgis::SensorThingsEntity::DatastreamRelation:
        case Qgis::SensorThingsEntity::ThingRelation:
        case Qgis::SensorThingsEntity::ObservationRelation:
        case Qgis::SensorThingsEntity::FeatureRelation:
          return Qgis::RelationshipCardinality::OneToMany;
 
        case Qgis::SensorThingsEntity::Observation:
        case Qgis::SensorThingsEntity::RelationRole:
        case Qgis::SensorThingsEntity::PreparationProcedure:
        case Qgis::SensorThingsEntity::Feature:
        case Qgis::SensorThingsEntity::SamplingProcedure:
        case Qgis::SensorThingsEntity::Sensor:
        case Qgis::SensorThingsEntity::ObservedProperty:
        case Qgis::SensorThingsEntity::Datastream:
        case Qgis::SensorThingsEntity::Invalid:
        case Qgis::SensorThingsEntity::Location:
        case Qgis::SensorThingsEntity::HistoricalLocation:
        case Qgis::SensorThingsEntity::FeatureOfInterest:
        case Qgis::SensorThingsEntity::MultiDatastream:
        case Qgis::SensorThingsEntity::Thing:
        case Qgis::SensorThingsEntity::Deployment:
        case Qgis::SensorThingsEntity::FeatureType:
        case Qgis::SensorThingsEntity::ObservingProcedure:
        case Qgis::SensorThingsEntity::PreparationStep:
        case Qgis::SensorThingsEntity::Sampling:
        case Qgis::SensorThingsEntity::Sampler:
 
          break;
      }
 
      break;
    }
  }
 
  valid = false;
  return Qgis::RelationshipCardinality::ManyToMany;
}
 
QString QgsSensorThingsUtils::asQueryString( Qgis::SensorThingsEntity baseType, const QList<QgsSensorThingsExpansionDefinition> &expansions )
{
  QString res;
  if ( expansions.empty() )
    return res;
 
  for ( int i = expansions.size() - 1; i >= 0; i-- )
  {
    const QgsSensorThingsExpansionDefinition &expansion = expansions.at( i );
    if ( !expansion.isValid() )
      continue;
 
    const Qgis::SensorThingsEntity parentType = i > 0 ? expansions.at( i - 1 ).childEntity() : baseType;
 
    res = expansion.asQueryString( parentType, res.isEmpty() ? QStringList() : QStringList { res } );
  }
 
  return res;
}