Create load report

// [WriteFile Name=CreateLoadReport, Category=UtilityNetwork]
// [Legal]
// Copyright 2021 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

#ifdef PCH_BUILD
#include "pch.hpp"
#endif // PCH_BUILD

// sample headers
#include "CreateLoadReport.h"

// ArcGIS Maps SDK headers
#include "ArcGISRuntimeEnvironment.h"
#include "Authentication/AuthenticationManager.h"
#include "Authentication/ArcGISAuthenticationChallenge.h"
#include "Authentication/TokenCredential.h"
#include "CodedValueDomain.h"
#include "ErrorException.h"
#include "MapQuickView.h"
#include "MapTypes.h"
#include "ServiceGeodatabase.h"
#include "UtilityAssetGroup.h"
#include "UtilityAssetType.h"
#include "UtilityCategory.h"
#include "UtilityCategoryComparison.h"
#include "UtilityDomainNetwork.h"
#include "UtilityElementTraceResult.h"
#include "UtilityFunctionTraceResult.h"
#include "UtilityNetwork.h"
#include "UtilityNetworkAttribute.h"
#include "UtilityNetworkAttributeComparison.h"
#include "UtilityNetworkDefinition.h"
#include "UtilityNetworkSource.h"
#include "UtilityNetworkTypes.h"
#include "UtilityTerminal.h"
#include "UtilityTerminalConfiguration.h"
#include "UtilityTier.h"
#include "UtilityTraceConfiguration.h"
#include "UtilityTraceFunction.h"
#include "UtilityTraceFunctionListModel.h"
#include "UtilityTraceFunctionOutput.h"
#include "UtilityTraceOrCondition.h"
#include "UtilityTraceParameters.h"
#include "UtilityTraceResultListModel.h"
#include "UtilityTraversability.h"

// Qt headers
#include <QFuture>

using namespace Esri::ArcGISRuntime;
using namespace Esri::ArcGISRuntime::Authentication;

CreateLoadReport::CreateLoadReport(QObject* parent /* = nullptr */):
  ArcGISAuthenticationChallengeHandler(parent)
{
  ArcGISRuntimeEnvironment::authenticationManager()->setArcGISAuthenticationChallengeHandler(this);

  m_networkSourceName = "Electric Distribution Device";
  m_assetGroupName = "Circuit Breaker";
  m_assetTypeName = "Three Phase";
  m_terminalName = "Load";
  m_globalId = "{1CAF7740-0BF4-4113-8DB2-654E18800028}";
  m_domainNetworkName = "ElectricDistribution";
  m_tierName = "Medium Voltage Radial";
  m_serviceCategoryName = "ServicePoint";
  m_loadNetworkAttributeName = "Service Load";
  m_phasesNetworkAttributeName = "Phases Current";
  m_sampleStatus = CreateLoadReport::SampleNotLoaded;

  m_utilityNetwork = new UtilityNetwork(new ServiceGeodatabase(m_featureLayerUrl, this), this);

  connect(m_utilityNetwork, &UtilityNetwork::loadStatusChanged, this, [this]()
  {
    if (m_utilityNetwork->loadStatus() == LoadStatus::Loaded)
    {
      m_utilityAssetType = m_utilityNetwork
          ->definition()
          ->networkSource(m_networkSourceName)
          ->assetGroup(m_assetGroupName)
          ->assetType(m_assetTypeName);

      m_utilityTier = m_utilityNetwork
          ->definition()
          ->domainNetwork(m_domainNetworkName)
          ->tier(m_tierName);

      // Create a UtilityElement from the UtilityAssetType to use as the starting location
      m_startingLocation = createStartingLocation();

      // Get a default trace configuration from a tier in the network
      m_traceConfiguration = createDefaultTraceConfiguration();

      // Create a base condition to compare against
      m_baseCondition = dynamic_cast<UtilityTraceConditionalExpression*>(m_utilityTier->defaultTraceConfiguration()->traversability()->barriers());

      // Create downstream trace parameters with function outputs
      m_traceParameters = new UtilityTraceParameters(UtilityTraceType::Downstream, {m_startingLocation}, this);
      m_traceParameters->setResultTypes({UtilityTraceResultType::Elements, UtilityTraceResultType::FunctionOutputs});
      // Assign the trace configuration to trace parameters.
      m_traceParameters->setTraceConfiguration(m_traceConfiguration);

      // Create a list of possible phases from a given network attribute
      m_phaseList = createPhaseList();

      m_sampleStatus = CreateLoadReport::SampleReady;
      emit sampleStatusChanged();
    }
    else if (m_utilityNetwork->loadStatus() == LoadStatus::FailedToLoad)
    {
      m_sampleStatus = CreateLoadReport::SampleError;
      emit sampleStatusChanged();
    }
  });

  m_utilityNetwork->load();
}

UtilityElement* CreateLoadReport::createStartingLocation()
{
  if (!m_utilityAssetType)
    return nullptr;

  const QList<UtilityTerminal*> utilityTerminals = m_utilityAssetType->terminalConfiguration()->terminals();
  if (!utilityTerminals.first())
    return nullptr;

  UtilityTerminal* loadTerminal = nullptr;

  for (UtilityTerminal* utilityTerminal : utilityTerminals)
  {
    // Set the terminal for the location. (For our case, use the "Load" terminal.)
    if (utilityTerminal->name() == m_terminalName)
    {
      loadTerminal = utilityTerminal;
      break;
    }
  }

  if (!loadTerminal)
    return nullptr;

  return m_utilityNetwork->createElementWithAssetType(m_utilityAssetType, QUuid(m_globalId), loadTerminal, this);
}

UtilityTraceConfiguration* CreateLoadReport::createDefaultTraceConfiguration()
{
  UtilityTraceConfiguration* traceConfig = m_utilityTier->defaultTraceConfiguration();

  // Service Category for counting total customers
  UtilityCategory* servicePointCategory = getUtilityCategory(m_serviceCategoryName);

  // The load attribute for counting total load.
  UtilityNetworkAttribute* serviceLoadAttribute = m_utilityNetwork->definition()->networkAttribute(m_loadNetworkAttributeName);

  // Create a comparison to check the existence of service points.
  UtilityCategoryComparison* serviceCategoryComparison = new UtilityCategoryComparison(servicePointCategory, UtilityCategoryComparisonOperator::Exists, this);
  UtilityTraceFunction* addLoadAttributeFunction = new UtilityTraceFunction(UtilityTraceFunctionType::Add, serviceLoadAttribute, serviceCategoryComparison, this);

  traceConfig->functions()->clear();

  // Create function input and output condition.
  traceConfig->functions()->append(addLoadAttributeFunction);
  traceConfig->setOutputCondition(serviceCategoryComparison);

  // Set to false to ensure that service points with incorrect phasing
  // (which therefore act as barriers) are not counted with results.
  traceConfig->setIncludeBarriers(false);

  return traceConfig;
}

UtilityCategory* CreateLoadReport::getUtilityCategory(const QString& categoryName)
{
  const QList<UtilityCategory*> utilityCategories = m_utilityNetwork->definition()->categories();

  for (UtilityCategory* utilityCategory : utilityCategories)
  {
    if (utilityCategory->name() == categoryName)
      return utilityCategory;
  }
  return nullptr;
}

QList<CodedValue> CreateLoadReport::createPhaseList()
{
  // The phase attribute for getting total phase current load.
  m_phasesCurrentAttribute = m_utilityNetwork->definition()->networkAttribute(m_phasesNetworkAttributeName);

  // Get possible coded phase values from the attributes.
  if (m_phasesCurrentAttribute->domain().domainType() == DomainType::CodedValueDomain)
  {
    const CodedValueDomain cvd = CodedValueDomain(m_phasesCurrentAttribute->domain());
    QList<CodedValue> codedValues = cvd.codedValues();

    return codedValues;
  }

  return {};
}

void CreateLoadReport::runReport(const QStringList& selectedPhaseNames)
{
  m_sampleStatus = CreateLoadReport::SampleBusy;
  emit sampleStatusChanged();

  QVector<CodedValue> activeValues;
  for (const CodedValue& codedValue : std::as_const(m_phaseList))
  {
    if (selectedPhaseNames.contains(codedValue.name()))
      activeValues.append(codedValue);

    // Reset the report values
    m_phaseCust.remove(codedValue.name());
    m_phaseLoad.remove(codedValue.name());

    emit loadReportUpdated();
  }
  m_traceRequestCount = activeValues.size();
  for (const CodedValue& codedValue : activeValues)
  {
    setUtilityTraceOrconditionWithCodedValue(codedValue);
    m_utilityNetwork->traceAsync(m_traceParameters).then(this, [this, codedValue](QList<UtilityTraceResult*>)
    {
      onTraceCompleted_(codedValue.name());
    });
  }

  // If no phases were selected then the sample was reset and can be marked ready
  if (selectedPhaseNames.size() == 0) {
    m_sampleStatus = CreateLoadReport::SampleReady;
    emit sampleStatusChanged();
  }
}

void CreateLoadReport::setUtilityTraceOrconditionWithCodedValue(CodedValue codedValue)
{
  if (!m_baseCondition)
    return;

  // Create a conditional expression with the CodedValue
  UtilityNetworkAttributeComparison* utilityNetworkAttributeComparison =
        new UtilityNetworkAttributeComparison(
          m_phasesCurrentAttribute,
          UtilityAttributeComparisonOperator::DoesNotIncludeAny,
          codedValue.code(), this);

  // Chain it with the base condition using an OR operator.
  UtilityTraceOrCondition* utilityTraceOrCondition = new UtilityTraceOrCondition(m_baseCondition, utilityNetworkAttributeComparison, this);
  m_traceParameters->traceConfiguration()->traversability()->setBarriers(utilityTraceOrCondition);
}

void CreateLoadReport::onTraceCompleted_(const QString& codedValueName)
{
  UtilityTraceResultListModel* results = m_utilityNetwork->traceResult();

  for (UtilityTraceResult* result : *results)
  {
    // Get the total customers from the UtilityElementTraceResult
    if (UtilityElementTraceResult* elementResult = dynamic_cast<UtilityElementTraceResult*>(result))
      m_phaseCust[codedValueName] = elementResult->elements(this).size();

    // Get the total load from the UtilityFunctionTraceResult
    else if (UtilityFunctionTraceResult* functionResult = dynamic_cast<UtilityFunctionTraceResult*>(result))
      m_phaseLoad[codedValueName] = std::as_const(functionResult)->functionOutputs().first()->result().toInt();
  }

  emit loadReportUpdated();
  // If the trace request count is zero, all trace tasks have completed
  if ((--m_traceRequestCount) == 0)
  {
    m_sampleStatus = CreateLoadReport::SampleReady;
    emit sampleStatusChanged();
  }
}

CreateLoadReport::~CreateLoadReport() = default;

void CreateLoadReport::init()
{
  qmlRegisterType<CreateLoadReport>("Esri.Samples", 1, 0, "CreateLoadReportSample");
}

void CreateLoadReport::addPhase(const QString& phaseToAdd)
{
  m_activePhases.append(phaseToAdd);
}

QVariantMap CreateLoadReport::phaseCust()
{
  return m_phaseCust;
}

QVariantMap CreateLoadReport::phaseLoad()
{
  return m_phaseLoad;
}

int CreateLoadReport::sampleStatus()
{
  return m_sampleStatus;
}

void CreateLoadReport::handleArcGISAuthenticationChallenge(ArcGISAuthenticationChallenge* challenge)
{
  TokenCredential::createWithChallengeAsync(challenge, "viewer01", "I68VGU^nMurF", {}, this).then(this, [challenge](TokenCredential* tokenCredential)
  {
    challenge->continueWithCredential(tokenCredential);
  }).onFailed(this, [challenge](const ErrorException& e)
  {
    challenge->continueWithError(e.error());
  });
}

// [WriteFile Name=CreateLoadReport, Category=UtilityNetwork]
// [Legal]
// Copyright 2021 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

#ifndef CREATELOADREPORT_H
#define CREATELOADREPORT_H

// ArcGIS Maps SDK headers
#include "Authentication/ArcGISAuthenticationChallengeHandler.h"

// Qt headers
#include <QObject>
#include <QUrl>
#include <QUuid>
#include <QVariantMap>

namespace Esri::ArcGISRuntime
{
class CodedValue;
class UtilityAssetType;
class UtilityCategory;
class UtilityElement;
class UtilityNetwork;
class UtilityNetworkAttribute;
class UtilityTier;
class UtilityTraceConditionalExpression;
class UtilityTraceConfiguration;
class UtilityTraceParameters;
}

namespace Esri::ArcGISRuntime::Authentication
{
  class ArcGISAuthenticationChallenge;
}

class CreateLoadReport : public Esri::ArcGISRuntime::Authentication::ArcGISAuthenticationChallengeHandler
{
  Q_OBJECT

  Q_PROPERTY(QVariantMap phaseCust READ phaseCust NOTIFY loadReportUpdated)
  Q_PROPERTY(QVariantMap phaseLoad READ phaseLoad NOTIFY loadReportUpdated)
  Q_PROPERTY(int sampleStatus READ sampleStatus NOTIFY sampleStatusChanged)

public:
  explicit CreateLoadReport(QObject* parent = nullptr);
  ~CreateLoadReport();

  static void init();
  Q_INVOKABLE void addPhase(const QString& phaseToAdd);
  Q_INVOKABLE void runReport(const QStringList& selectedPhaseNames);

  enum SampleStatus
  {
    SampleError = -1,
    SampleNotLoaded = 0,
    SampleBusy = 1,
    SampleReady = 2
  };
  Q_ENUM(SampleStatus)

signals:
  void loadReportUpdated();
  void sampleStatusChanged();

private:
  int sampleStatus();
  QVariantMap phaseCust();
  QVariantMap phaseLoad();

  Esri::ArcGISRuntime::UtilityCategory* getUtilityCategory(const QString& categoryName);
  Esri::ArcGISRuntime::UtilityElement* createStartingLocation();
  Esri::ArcGISRuntime::UtilityTraceConfiguration* createDefaultTraceConfiguration();
  QList<Esri::ArcGISRuntime::CodedValue> createPhaseList();
  void onTraceCompleted_(const QString& codeValueName);
  void setUtilityTraceOrconditionWithCodedValue(Esri::ArcGISRuntime::CodedValue);

  void handleArcGISAuthenticationChallenge(Esri::ArcGISRuntime::Authentication::ArcGISAuthenticationChallenge* challenge) override;

  Esri::ArcGISRuntime::UtilityAssetType* m_utilityAssetType = nullptr;
  Esri::ArcGISRuntime::UtilityElement* m_startingLocation = nullptr;
  Esri::ArcGISRuntime::UtilityNetwork* m_utilityNetwork = nullptr;
  Esri::ArcGISRuntime::UtilityNetworkAttribute* m_phasesCurrentAttribute = nullptr;
  Esri::ArcGISRuntime::UtilityTier* m_utilityTier = nullptr;
  Esri::ArcGISRuntime::UtilityTraceConditionalExpression* m_baseCondition = nullptr;
  Esri::ArcGISRuntime::UtilityTraceConfiguration* m_traceConfiguration = nullptr;
  Esri::ArcGISRuntime::UtilityTraceParameters* m_traceParameters = nullptr;
  QList<Esri::ArcGISRuntime::CodedValue> m_phaseList;
  QStringList m_activePhases;
  QVariantMap m_phaseCust;
  QVariantMap m_phaseLoad;

  int m_sampleStatus;
  QString m_assetGroupName;
  QString m_assetTypeName;
  QString m_domainNetworkName;
  QString m_globalId;
  QString m_loadNetworkAttributeName;
  QString m_networkSourceName;
  QString m_phasesNetworkAttributeName;
  QString m_serviceCategoryName;
  QString m_terminalName;
  QString m_tierName;
  const QUrl m_featureLayerUrl = QUrl("https://sampleserver7.arcgisonline.com/server/rest/services/UtilityNetwork/NapervilleElectric/FeatureServer");
  int m_traceRequestCount;
};

#endif // CREATELOADREPORT_H

// [WriteFile Name=CreateLoadReport, Category=UtilityNetwork]
// [Legal]
// Copyright 2021 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

import QtQuick
import QtQuick.Controls
import QtQuick.Layouts
import Esri.Samples

Item {
    property var phases: ["A", "AB", "ABC", "AC", "B", "BC", "C", "DeEnergized", "Unknown"]
    property var selectedPhases: ({})
    property bool reportHasRun: false

    CreateLoadReportSample {
        id: sampleModel
    }

    ScrollView {
        id: rectangle
        anchors.centerIn: parent
        width: children.width
        height: parent.height

        Column {
            id: contents
            padding: 20
            spacing: 10

            Row {
                ButtonGroup {
                    id: checkBoxes
                    exclusive: false
                    checkState: parentBox.checkState
                }

                GridLayout {
                    id: grid
                    rows: phases.length + 1
                    flow: GridLayout.TopToBottom

                    CheckBox { id: parentBox; checkState: checkBoxes.checkState }
                    Repeater {
                        id: phaseCheckBoxes
                        model: phases
                        CheckBox { onCheckedChanged: selectedPhases[modelData] = !selectedPhases[modelData]; ButtonGroup.group: checkBoxes }
                    }

                    Text { text: "Phase"; font.pointSize: 18; font.bold: true }
                    Repeater {
                        id: phaseLabels
                        model: phases
                        Text { text: modelData }
                    }

                    Text { text: "Total customers"; font.pointSize: 18; font.bold: true; }
                    Repeater {
                        id: phaseCustomerValues
                        model: phases
                        Text { text: modelData in sampleModel.phaseCust ? sampleModel.phaseCust[modelData].toLocaleString(Qt.locale(), "f", 0) : "NA" }
                    }

                    Text { text: "Total load"; font.bold: true; font.pointSize: 18 }
                    Repeater {
                        id: phaseLoadValues
                        model: phases
                        Text { text: modelData in sampleModel.phaseLoad ? sampleModel.phaseLoad[modelData].toLocaleString(Qt.locale(), "f", 0) : "NA" }
                    }
                }
            }

            Row {
                Button {
                    text: checkBoxes.checkState !== 0 || !reportHasRun ? "Run Report" : "Reset"

                    enabled: ((reportHasRun || checkBoxes.checkState !== 0) && sampleModel.sampleStatus === 2) ? true : false

                    onClicked: {
                        let phasesToRun = [];
                        phases.forEach((phase) => {
                                           if (selectedPhases[phase])
                                           phasesToRun.push(phase)
                                       });
                        sampleModel.runReport(phasesToRun);

                        reportHasRun = phasesToRun.length !== 0;
                    }
                }
            }

            Row {
                Text {
                    id: noticeText
                    text: {
                        switch (sampleModel.sampleStatus) {
                        case CreateLoadReportSample.SampleError: // SampleError
                            "Error initializing sample";
                            break;
                        case CreateLoadReportSample.SampleNotLoaded: // SampleNotLoaded
                            "Sample initializing...";
                            break;
                        case CreateLoadReportSample.SampleBusy: // SampleBusy
                            "Generating load report...";
                            break;
                        case CreateLoadReportSample.SampleReady: // SampleReady
                            if (checkBoxes.checkState === 0 && !reportHasRun) {
                                "Select phases to include in the load report";
                            } else {
                                "Tap the \"Run Report\" button to create the load report";
                            }
                            break;
                        default:
                            "Sample status is not defined";
                            break;
                        }
                    }
                }
            }
        }
    }
}

// [Legal]
// Copyright 2021 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// [Legal]

// sample headers
#include "CreateLoadReport.h"

// ArcGIS Maps SDK headers
#include "ArcGISRuntimeEnvironment.h"

// Qt headers
#include <QDir>
#include <QGuiApplication>
#include <QQmlApplicationEngine>

// Platform specific headers
#ifdef Q_OS_WIN
#include <Windows.h>
#endif

int main(int argc, char *argv[])
{
  Esri::ArcGISRuntime::ArcGISRuntimeEnvironment::setUseLegacyAuthentication(false);
  QGuiApplication app(argc, argv);
  app.setApplicationName(QString("CreateLoadReport"));

  // Use of ArcGIS location services, such as basemap styles, geocoding, and routing services,
  // requires an access token. For more information see
  // https://links.esri.com/arcgis-runtime-security-auth.

  // The following methods grant an access token:

  // 1. User authentication: Grants a temporary access token associated with a user's ArcGIS account.
  // To generate a token, a user logs in to the app with an ArcGIS account that is part of an
  // organization in ArcGIS Online or ArcGIS Enterprise.

  // 2. API key authentication: Get a long-lived access token that gives your application access to
  // ArcGIS location services. Go to the tutorial at https://links.esri.com/create-an-api-key.
  // Copy the API Key access token.

  const QString accessToken = QString("");

  if (accessToken.isEmpty())
  {
      qWarning() << "Use of ArcGIS location services, such as the basemap styles service, requires" <<
                    "you to authenticate with an ArcGIS account or set the API Key property.";
  }
  else
  {
      Esri::ArcGISRuntime::ArcGISRuntimeEnvironment::setApiKey(accessToken);
  }

  // Initialize the sample
  CreateLoadReport::init();

  // Initialize application view
  QQmlApplicationEngine engine;
  // Add the import Path
  engine.addImportPath(QDir(QCoreApplication::applicationDirPath()).filePath("qml"));

#ifdef ARCGIS_RUNTIME_IMPORT_PATH_2
  engine.addImportPath(ARCGIS_RUNTIME_IMPORT_PATH_2);
#endif

  // Set the source
  engine.load(QUrl("qrc:/Samples/UtilityNetwork/CreateLoadReport/main.qml"));

  return app.exec();
}

// Copyright 2021 Esri.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0

// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import QtQuick
import QtQuick.Controls
import Esri.Samples
import Qt.labs.qmlmodels

ApplicationWindow {
    visible: true
    width: 800
    height: 600

    CreateLoadReport {
        anchors.fill: parent
    }
}