diff --git a/.env.example b/.env.example index b223c89f3..a0ff68a99 100644 --- a/.env.example +++ b/.env.example @@ -3,6 +3,8 @@ # Define POSTGRES PORT for Docker when calling datamodel/scripts/run-docker.sh TWW_PG_PORT=5432 +QGIS_TEST_VERSION + # fix access rights for schemaspy UID=1000 GID=1001 diff --git a/.github/workflows/plugin-package.yml b/.github/workflows/plugin-package.yml new file mode 100644 index 000000000..3d7c227e7 --- /dev/null +++ b/.github/workflows/plugin-package.yml @@ -0,0 +1,54 @@ +name: 🔌 Plugin | Package and release + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +on: + push: + branches: + - main + pull_request: + branches: + - main + paths: + - plugin/** + - '.github/workflows/datamodel-create-dumps.yml' + workflow_dispatch: + + +jobs: + plugin-package: + name: Packages and releases plugin + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.10' + + - name: Install qgis-plugin-ci + run: pip install qgis-plugin-ci>=2.8.6 + + - name: Package PyPI Packages + run: ./plugin/scripts/package-pip-packages.sh + + - name: Download Interlis libs + run: ./plugin/scripts/download-interlis-libs.sh + + - name: Package + run: | + VERSION=0.0.0 + qgis-plugin-ci -v package ${VERSION} \ + --allow-uncommitted-changes \ + --asset-path plugin/teksi_wastewater/libs \ + --asset-path plugin/teksi_wastewater/interlis/bin + + - uses: actions/upload-artifact@v3 + with: + name: teksi_wastewater_plugin_dev + path: plugin/teksi_wastewater.0.0.0.zip + if-no-files-found: error diff --git a/.github/workflows/plugin-test.yml b/.github/workflows/plugin-test.yml new file mode 100644 index 000000000..6e280c2af --- /dev/null +++ b/.github/workflows/plugin-test.yml @@ -0,0 +1,57 @@ +name: 🪲 Plugin | Tests + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +on: + push: + branches: + - main + paths: + - datamodel/** + - plugin/** + - '.github/workflows/plugin-test.yml' + pull_request: + branches: + - main + paths: + - datamodel/** + - plugin/** + - '.github/workflows/plugin-test.yml' + workflow_dispatch: + + +jobs: + plugin-tests: + name: Run unit tests on plugin + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + qgis_version: [3.28-jammy, latest] + env: + QGIS_TEST_VERSION: ${{ matrix.qgis_version }} + COMPOSE_PROFILES: qgis + + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Package PyPI Packages + run: sudo ./plugin/scripts/package-pip-packages.sh + + - name: Download Interlis libs + run: sudo ./plugin/scripts/download-interlis-libs.sh + + - name: Docker build + run: docker compose up -d --build + + - name: Test on QGIS + run: docker-compose run qgis /usr/src/.docker/run-docker-tests.sh + + - name: docker logs + #if: failure() + run: docker compose logs db diff --git a/.gitignore b/.gitignore index be3994ebb..fa1ab85ba 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,12 @@ datamodel/artifacts project/*attachments.zip project/*.qgs~ +plugin/teksi_wastewater/libs/ +plugin/teksi_wastewater/interlis/bin +plugin*.zip +plugin*.tar.gz + .idea .pycache __pycache__ +.DS_Store diff --git a/.qgis-plugin-ci b/.qgis-plugin-ci new file mode 100644 index 000000000..64392b0db --- /dev/null +++ b/.qgis-plugin-ci @@ -0,0 +1,3 @@ +plugin_path: plugin/teksi_wastewater +github_organization_slug: TEKSI +project_slug: wastewater diff --git a/docker-compose.yml b/docker-compose.yml index b8787bf8e..7fcb37cfc 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -13,6 +13,20 @@ services: # making the postgres database accessible for debugging - ${TWW_PG_PORT:-5432}:${TWW_PG_PORT:-5432} + qgis: + build: + context: . + dockerfile: plugin/.docker/Dockerfile + args: + QGIS_TEST_VERSION: ${QGIS_TEST_VERSION:-latest} + tty: true + volumes: + - ./plugin:/usr/src + links: + - db + profiles: + - qgis + schemaspy: image: schemaspy/schemaspy volumes: diff --git a/plugin/.docker/Dockerfile b/plugin/.docker/Dockerfile new file mode 100644 index 000000000..28e867584 --- /dev/null +++ b/plugin/.docker/Dockerfile @@ -0,0 +1,14 @@ +ARG QGIS_TEST_VERSION=latest +FROM opengisch/qgis:${QGIS_TEST_VERSION} + +# remove QGIS apt repo to avoid signing key issues +RUN add-apt-repository -r https://qgis.org/ubuntu && \ + add-apt-repository -r https://qgis.org/ubuntu-ltr + +RUN apt-get update && \ + apt-get -y install openjdk-8-jre curl locales postgresql-client python3-geoalchemy2 \ + && rm -rf /var/lib/apt/lists/* + +ENV LANG=C.UTF-8 + +WORKDIR / diff --git a/plugin/.docker/run-docker-tests.sh b/plugin/.docker/run-docker-tests.sh new file mode 100755 index 000000000..1adf7e24f --- /dev/null +++ b/plugin/.docker/run-docker-tests.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +#*************************************************************************** +# ------------------- +# begin : 2017-08-24 +# git sha : :%H$ +# copyright : (C) 2017 by OPENGIS.ch +# email : info@opengis.ch +#*************************************************************************** +# +#*************************************************************************** +#* * +#* 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. * +#* * +#*************************************************************************** + +set -e + +pushd /usr/src +DEFAULT_PARAMS='-v' +xvfb-run pytest-3 ${@:-`echo $DEFAULT_PARAMS`} $1 +popd diff --git a/plugin/README.md b/plugin/README.md deleted file mode 100644 index 6af884e44..000000000 --- a/plugin/README.md +++ /dev/null @@ -1 +0,0 @@ -Here comes the QGIS plugin for this module diff --git a/plugin/scripts/download-interlis-libs.sh b/plugin/scripts/download-interlis-libs.sh new file mode 100755 index 000000000..c2e482cd9 --- /dev/null +++ b/plugin/scripts/download-interlis-libs.sh @@ -0,0 +1,4 @@ +#!/usr/bin/env bash + +wget https://github.com/teksi/wastewater/archive/refs/tags/plugin-ili-libs-1.tar.gz +tar xvzf plugin-ili-libs-1.tar.gz --strip-components=1 diff --git a/plugin/scripts/package-pip-packages.sh b/plugin/scripts/package-pip-packages.sh new file mode 100755 index 000000000..4353e812b --- /dev/null +++ b/plugin/scripts/package-pip-packages.sh @@ -0,0 +1,31 @@ +#!/usr/bin/env bash + +LIBS_DIR="plugin/teksi_wastewater/libs" + +MODELBAKER_LIBRARY=("modelbaker" "1.6.0") + +PACKAGES=( + MODELBAKER_LIBRARY[@] +) + +#create lib folder +mkdir -p $LIBS_DIR + +for PACKAGE in ${PACKAGES[@]}; do + echo download and unpack ${!PACKAGE:0:1} with version ${!PACKAGE:1:1} + #create temp folder + mkdir -p temp + #download the wheel + pip download -v ${!PACKAGE:0:1}==${!PACKAGE:1:1} --only-binary :all: -d temp/ + #unpack all the wheels found (means including dependencies) + unzip -o "temp/*.whl" -d $LIBS_DIR + #remove temp folder + rm -r temp + #set write rights to group (because qgis-plugin-ci needs it) + chmod -R g+w $LIBS_DIR +done + +#create the __init__.py in libs folder +cd $LIBS_DIR +touch __init__.py +chmod g+w __init__.py diff --git a/plugin/scripts/run-tests.sh b/plugin/scripts/run-tests.sh new file mode 100755 index 000000000..993087d24 --- /dev/null +++ b/plugin/scripts/run-tests.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +# Arguments are passed one to one to pytest +# +# Run all tests: +# ./scripts/run-tests.sh # Run all tests +# +# Run all test starting with test_array_ +# ./scripts/run-tests.sh -k test_array_ + +docker-compose run qgis /usr/src/.docker/run-docker-tests.sh $@ diff --git a/plugin/teksi_wastewater/__init__.py b/plugin/teksi_wastewater/__init__.py new file mode 100644 index 000000000..6646daeee --- /dev/null +++ b/plugin/teksi_wastewater/__init__.py @@ -0,0 +1,29 @@ +# ----------------------------------------------------------- +# +# TEKSI Wastewater +# Copyright (C) 2012 Matthias Kuhn +# ----------------------------------------------------------- +# +# licensed under the terms of GNU GPL 2 +# +# 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. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# --------------------------------------------------------------------- + + +def classFactory(iface): + from .teksi_wastewater_plugin import TeksiWastewaterPlugin + + return TeksiWastewaterPlugin(iface) diff --git a/plugin/teksi_wastewater/gui/__init__.py b/plugin/teksi_wastewater/gui/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/plugin/teksi_wastewater/gui/dlgabout.py b/plugin/teksi_wastewater/gui/dlgabout.py new file mode 100644 index 000000000..5f00b9214 --- /dev/null +++ b/plugin/teksi_wastewater/gui/dlgabout.py @@ -0,0 +1,51 @@ +# ----------------------------------------------------------- +# +# Profile +# Copyright (C) 2012 Patrice Verchere +# ----------------------------------------------------------- +# +# licensed under the terms of GNU GPL 2 +# +# 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. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, print to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# --------------------------------------------------------------------- + +import os + +from qgis.PyQt.QtCore import QSettings +from qgis.PyQt.QtWidgets import QDialog + +from ..utils import get_ui_class + +DIALOG_UI = get_ui_class("dlgabout.ui") + + +class DlgAbout(QDialog, DIALOG_UI): + def __init__(self, parent=None): + QDialog.__init__(self, parent) + self.setupUi(self) + + fp = os.path.join( + os.path.abspath(os.path.join(os.path.dirname(__file__), "..")), + "metadata.txt", + ) + + ini_text = QSettings(fp, QSettings.IniFormat) + verno = ini_text.value("version") + name = ini_text.value("name") + description = ini_text.value("description") + + self.title.setText(name) + self.description.setText(description + " - " + verno) diff --git a/plugin/teksi_wastewater/gui/forms.py b/plugin/teksi_wastewater/gui/forms.py new file mode 100644 index 000000000..0e9d39d18 --- /dev/null +++ b/plugin/teksi_wastewater/gui/forms.py @@ -0,0 +1,26 @@ +import qgis +from qgis.core import QgsProject + +from ..tools.twwmaptooladdfeature import TwwMapToolDigitizeDrainageChannel + + +def geometryDigitized(fid, layer, tool): + layer.changeGeometry(fid, tool.geometry) + layer.triggerRepaint() + tool.deactivate() + + +def mapToolDeactivated(tool): + tool.deactivated.disconnect() + qgis.utils.plugins["teksi_wastewater"].iface.mapCanvas().unsetMapTool(tool) + tool.deleteLater() + + +def digitizeDrainageChannel(fid, layerid): + layer = QgsProject.instance().mapLayer(layerid) + layer.startEditing() + tool = TwwMapToolDigitizeDrainageChannel(qgis.utils.plugins["teksi_wastewater"].iface, layer) + qgis.utils.plugins["teksi_wastewater"].iface.mapCanvas().setMapTool(tool) + tool.geometryDigitized.connect(lambda: geometryDigitized(fid, layer, tool)) + # form.window().hide() + tool.deactivated.connect(lambda: mapToolDeactivated(tool)) diff --git a/plugin/teksi_wastewater/gui/twwplotsvgwidget.py b/plugin/teksi_wastewater/gui/twwplotsvgwidget.py new file mode 100644 index 000000000..41a3fb1cd --- /dev/null +++ b/plugin/teksi_wastewater/gui/twwplotsvgwidget.py @@ -0,0 +1,171 @@ +# ----------------------------------------------------------- +# +# Profile +# Copyright (C) 2012 Matthias Kuhn +# ----------------------------------------------------------- +# +# licensed under the terms of GNU GPL 2 +# +# 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. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this progsram; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# --------------------------------------------------------------------- + +import logging + +from qgis.PyQt.QtCore import QSettings, Qt, QUrl, pyqtSignal, pyqtSlot +from qgis.PyQt.QtPrintSupport import QPrinter, QPrintPreviewDialog +from qgis.PyQt.QtWebKit import QWebSettings +from qgis.PyQt.QtWebKitWidgets import QWebPage, QWebView +from qgis.PyQt.QtWidgets import QVBoxLayout, QWidget + +from ..tools.twwnetwork import TwwGraphManager +from ..utils.translation import TwwJsTranslator +from ..utils.ui import plugin_root_path + + +class TwwWebPage(QWebPage): + logger = logging.getLogger(__name__) + + def __init__(self, parent): + QWebPage.__init__(self, parent) + + def javaScriptConsoleMessage(self, msg, line, source): + self.logger.debug(f"{source} line {line}: {msg}") + + +class TwwPlotSVGWidget(QWidget): + webView = None + webPage = None + frame = None + profile = None + verticalExaggeration = 10 + jsTranslator = TwwJsTranslator() + + # Signals emitted triggered by javascript actions + reachClicked = pyqtSignal([str], name="reachClicked") + reachMouseOver = pyqtSignal([str], name="reachMouseOver") + reachMouseOut = pyqtSignal([str], name="reachMouseOut") + reachPointClicked = pyqtSignal([str, str], name="reachPointClicked") + reachPointMouseOver = pyqtSignal([str, str], name="reachPointMouseOver") + reachPointMouseOut = pyqtSignal([str, str], name="reachPointMouseOut") + specialStructureClicked = pyqtSignal([str], name="specialStructureClicked") + specialStructureMouseOver = pyqtSignal([str], name="specialStructureMouseOver") + specialStructureMouseOut = pyqtSignal([str], name="specialStructureMouseOut") + + # Signals emitted for javascript + profileChanged = pyqtSignal([str], name="profileChanged") + verticalExaggerationChanged = pyqtSignal([int], name="verticalExaggerationChanged") + + def __init__(self, parent, network_analyzer: TwwGraphManager, url: str = None): + QWidget.__init__(self, parent) + + self.webView = QWebView() + self.webView.setPage(TwwWebPage(self.webView)) + + self.networkAnalyzer = network_analyzer + + settings = QSettings() + + layout = QVBoxLayout(self) + if url is None: + # Starting with QGIS 3.4, QWebView requires paths with / even on windows. + default_url = plugin_root_path().replace("\\", "/") + "/svgprofile/index.html" + url = settings.value("/TWW/SvgProfilePath", default_url) + url = "file:///" + url + + developer_mode = settings.value("/TWW/DeveloperMode", False, type=bool) + + if developer_mode is True: + self.webView.page().settings().setAttribute(QWebSettings.DeveloperExtrasEnabled, True) + else: + self.webView.setContextMenuPolicy(Qt.NoContextMenu) + + self.webView.load(QUrl(url)) + self.frame = self.webView.page().mainFrame() + self.frame.javaScriptWindowObjectCleared.connect(self.initJs) + + layout.addWidget(self.webView) + + def setProfile(self, profile): + self.profile = profile + # Forward to javascript + self.profileChanged.emit(profile.asJson()) + + def initJs(self): + self.frame.addToJavaScriptWindowObject("profileProxy", self) + self.frame.addToJavaScriptWindowObject("i18n", self.jsTranslator) + + def changeVerticalExaggeration(self, val): + self.verticalExaggeration = val + self.verticalExaggerationChanged.emit(val) + + def printProfile(self): + printer = QPrinter(QPrinter.HighResolution) + printer.setOutputFormat(QPrinter.PdfFormat) + printer.setPaperSize(QPrinter.A4) + printer.setOrientation(QPrinter.Landscape) + + printpreviewdlg = QPrintPreviewDialog() + printpreviewdlg.paintRequested.connect(self.printRequested) + + printpreviewdlg.exec_() + + @pyqtSlot(QPrinter) + def printRequested(self, printer): + self.webView.print_(printer) + + @pyqtSlot(str) + def onReachClicked(self, obj_id): + self.reachClicked.emit(obj_id) + + @pyqtSlot(str) + def onReachMouseOver(self, obj_id): + self.reachMouseOver.emit(obj_id) + + @pyqtSlot(str) + def onReachMouseOut(self, obj_id): + self.reachMouseOut.emit(obj_id) + + @pyqtSlot(str, str) + def onReachPointClicked(self, obj_id, reach_obj_id): + self.reachPointClicked.emit(obj_id, reach_obj_id) + + @pyqtSlot(str, str) + def onReachPointMouseOver(self, obj_id, reach_obj_id): + self.reachPointMouseOver.emit(obj_id, reach_obj_id) + + @pyqtSlot(str, str) + def onReachPointMouseOut(self, obj_id, reach_obj_id): + self.reachPointMouseOut.emit(obj_id, reach_obj_id) + + @pyqtSlot(str) + def onSpecialStructureClicked(self, obj_id): + self.specialStructureClicked.emit(obj_id) + + @pyqtSlot(str) + def onSpecialStructureMouseOver(self, obj_id): + self.specialStructureMouseOver.emit(obj_id) + + @pyqtSlot(str) + def onSpecialStructureMouseOut(self, obj_id): + self.specialStructureMouseOut.emit(obj_id) + + # Is called from the webView when it's been reloaded and wants to have the + # profile information resent + @pyqtSlot() + def updateProfile(self): + if self.profile: + self.profileChanged.emit(self.profile.asJson()) + self.verticalExaggerationChanged.emit(self.verticalExaggeration) diff --git a/plugin/teksi_wastewater/gui/twwprofiledockwidget.py b/plugin/teksi_wastewater/gui/twwprofiledockwidget.py new file mode 100644 index 000000000..57dbc709d --- /dev/null +++ b/plugin/teksi_wastewater/gui/twwprofiledockwidget.py @@ -0,0 +1,232 @@ +# ----------------------------------------------------------- +# +# Profile +# Copyright (C) 2012 Matthias Kuhn +# ----------------------------------------------------------- +# +# licensed under the terms of GNU GPL 2 +# +# 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. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, print to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# --------------------------------------------------------------------- + + +from qgis.core import QgsFeatureRequest, QgsProject +from qgis.PyQt.QtCore import Qt, pyqtSignal, pyqtSlot +from qgis.PyQt.QtWidgets import ( + QAction, + QCheckBox, + QDialog, + QDialogButtonBox, + QDockWidget, + QGridLayout, + QMessageBox, +) + +from ..utils import get_ui_class +from ..utils.twwlayermanager import TwwLayerManager + +DOCK_WIDGET_UI = get_ui_class("twwdockwidget.ui") + + +class TwwProfileDockWidget(QDockWidget, DOCK_WIDGET_UI): + # Signal emitted when the widget is closed + closed = pyqtSignal() + canvas = None + addDockWidget = None + # Lookup table for vertical exaggeration values + veLUT = {1: 1, 2: 2, 3: 3, 4: 5, 5: 10, 6: 20, 7: 30, 8: 50, 9: 100, 10: 500} + + def __init__(self, parent, canvas, add_dock_widget): + QDockWidget.__init__(self, parent) + self.setupUi(self) + + self.selectCurrentPathAction = QAction(self.tr("Select current path"), self.selectButton) + self.selectCurrentPathAction.triggered.connect(self.onSelectCurrentPathAction) + self.selectButton.setDefaultAction(self.selectCurrentPathAction) + self.configureSelectionAction = QAction(self.tr("Configure Select"), self.selectButton) + self.configureSelectionAction.triggered.connect(self.onConfigureSelectAction) + self.selectButton.addAction(self.configureSelectionAction) + self.setAttribute(Qt.WA_DeleteOnClose) + self.canvas = canvas + self.addDockWidget = add_dock_widget + + self.plotWidget = None + + def showIt(self): + # self.setLocation( Qt.BottomDockWidgetArea ) + self.location = Qt.BottomDockWidgetArea + minsize = self.minimumSize() + maxsize = self.maximumSize() + self.setMinimumSize(minsize) + self.setMaximumSize(maxsize) + self.canvas.setRenderFlag(False) + + self.addDockWidget(self.location, self) + self.canvas.setRenderFlag(True) + + self.printButton.clicked.connect(self.onPrintButtonClicked) + + self.mSliderVerticalExaggeration.valueChanged.connect(self.onVerticalExaggerationChanged) + + def closeEvent(self, event): + self.closed.emit() + return QDockWidget.closeEvent(self, event) + + def addPlotWidget(self, plot_widget): + self.plotWidget = plot_widget + self.verticalLayoutForPlot.addWidget(self.plotWidget) + ve_val = self.veLUT[self.mSliderVerticalExaggeration.value()] + self.plotWidget.changeVerticalExaggeration(ve_val) + + @pyqtSlot(int) + def onVerticalExaggerationChanged(self, value): + ve_val = self.veLUT[value] + self.mLblVerticalExaggeration.setText(str(ve_val) + "x") + + if self.plotWidget: + self.plotWidget.changeVerticalExaggeration(ve_val) + + @pyqtSlot() + def onPrintButtonClicked(self): + if not self.plotWidget: + QMessageBox.critical( + self, + self.tr("Print function not available"), + self.tr("Print function not available because of missing dependeny QtWebKit"), + ) + return + + self.plotWidget.printProfile() + + @pyqtSlot() + def onConfigureSelectAction(self): + dlg = QDialog() + dlg.setWindowTitle(self.tr("Selection Options")) + dlg.setLayout(QGridLayout()) + + ww_current_checkbox = QCheckBox(self.tr("Wastewater current")) + status, _ = QgsProject.instance().readBoolEntry("Tww", "FollowWastewaterCurrent", True) + ww_current_checkbox.setChecked(status) + ww_planned_checkbox = QCheckBox(self.tr("Wastewater planned")) + status, _ = QgsProject.instance().readBoolEntry("Tww", "FollowWastewaterPlanned", True) + ww_planned_checkbox.setChecked(status) + rw_current_checkbox = QCheckBox(self.tr("Rainwater current")) + status, _ = QgsProject.instance().readBoolEntry("Tww", "FollowRainwaterCurrent", True) + rw_current_checkbox.setChecked(status) + rw_planned_checkbox = QCheckBox(self.tr("Rainwater planned")) + status, _ = QgsProject.instance().readBoolEntry("Tww", "FollowRainwaterPlanned", True) + rw_planned_checkbox.setChecked(status) + btn_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) + btn_box.accepted.connect(dlg.accept) + btn_box.rejected.connect(dlg.reject) + dlg.layout().addWidget(ww_current_checkbox) + dlg.layout().addWidget(ww_planned_checkbox) + dlg.layout().addWidget(rw_current_checkbox) + dlg.layout().addWidget(rw_planned_checkbox) + dlg.layout().addWidget(btn_box) + + if dlg.exec_(): + QgsProject.instance().writeEntry( + "Tww", "FollowWastewaterCurrent", ww_current_checkbox.isChecked() + ) + QgsProject.instance().writeEntry( + "Tww", "FollowWastewaterPlanned", ww_planned_checkbox.isChecked() + ) + QgsProject.instance().writeEntry( + "Tww", "FollowRainwaterCurrent", rw_current_checkbox.isChecked() + ) + QgsProject.instance().writeEntry( + "Tww", "FollowRainwaterPlanned", rw_planned_checkbox.isChecked() + ) + + @pyqtSlot() + def onSelectCurrentPathAction(self): + reaches = list() + wastewater_nodes = list() + wastewater_structures = list() + + for item in self.edges: + item_information = item[2] + if item_information["objType"] == "reach": + reaches.append(item_information["baseFeature"]) + + for item in self.nodes: + if item["objType"] == "wastewater_node": + wastewater_nodes.append(item["objId"]) + + tww_wastewater_structures_layer = TwwLayerManager.layer("vw_tww_wastewater_structure") + wastewater_nodes_layer = TwwLayerManager.layer("vw_wastewater_node") + tww_reach_layer = TwwLayerManager.layer("vw_tww_reach") + catchment_areas_layer = TwwLayerManager.layer("od_catchment_area") + + wastewater_node_list = ",".join("'" + id + "'" for id in wastewater_nodes) + reach_list = ",".join("'" + id + "'" for id in reaches) + + if catchment_areas_layer: + request = QgsFeatureRequest() + filters = list() + if QgsProject.instance().readBoolEntry("Tww", "FollowWastewaterCurrent", True)[0]: + filters.append( + f"fk_wastewater_networkelement_ww_current IN ({wastewater_node_list})" + ) + if QgsProject.instance().readBoolEntry("Tww", "FollowWastewaterPlanned", True)[0]: + filters.append( + f"fk_wastewater_networkelement_ww_planned IN ({wastewater_node_list})" + ) + if QgsProject.instance().readBoolEntry("Tww", "FollowRainwaterCurrent", True)[0]: + filters.append( + f"fk_wastewater_networkelement_rw_current IN ({wastewater_node_list})" + ) + if QgsProject.instance().readBoolEntry("Tww", "FollowRainwaterPlanned", True)[0]: + filters.append( + f"fk_wastewater_networkelement_rw_planned IN ({wastewater_node_list})" + ) + + if filters: + request.setFilterExpression(" OR ".join(filters)) + features = catchment_areas_layer.getFeatures(request) + catchment_areas_layer.select([f.id() for f in features]) + + if tww_reach_layer: + request = QgsFeatureRequest() + request.setFilterExpression(f"obj_id IN ({reach_list})") + features = tww_reach_layer.getFeatures(request) + tww_reach_layer.select([f.id() for f in features]) + + if wastewater_nodes_layer: + request = QgsFeatureRequest() + request.setFilterExpression(f"obj_id IN ({wastewater_node_list})") + features = wastewater_nodes_layer.getFeatures(request) + ids = list() + for feature in features: + ids.append(feature.id()) + wastewater_structures.append(feature["fk_wastewater_structure"]) + wastewater_nodes_layer.select(ids) + + wastewater_structure_list = ",".join( + "'" + id + "'" for id in wastewater_structures if type(id) is str + ) + + if tww_wastewater_structures_layer: + request = QgsFeatureRequest() + request.setFilterExpression(f"obj_id IN ({wastewater_structure_list})") + features = tww_wastewater_structures_layer.getFeatures(request) + tww_wastewater_structures_layer.select([f.id() for f in features]) + + def setTree(self, nodes, edges): + self.nodes = nodes + self.edges = edges + self.selectCurrentPathAction.setEnabled(self.nodes is not None) diff --git a/plugin/teksi_wastewater/gui/twwsettingsdialog.py b/plugin/teksi_wastewater/gui/twwsettingsdialog.py new file mode 100644 index 000000000..9b7ba3bb0 --- /dev/null +++ b/plugin/teksi_wastewater/gui/twwsettingsdialog.py @@ -0,0 +1,186 @@ +# ----------------------------------------------------------- +# +# Profile +# Copyright (C) 2012 Matthias Kuhn +# ----------------------------------------------------------- +# +# licensed under the terms of GNU GPL 2 +# +# 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. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, print to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# --------------------------------------------------------------------- + +import logging + +from qgis.core import QgsProject +from qgis.PyQt.QtCore import QSettings, pyqtSlot +from qgis.PyQt.QtGui import QColor +from qgis.PyQt.QtWidgets import QDialog, QFileDialog + +from ..utils import get_ui_class + +DIALOG_UI = get_ui_class("twwsettingsdialog.ui") + +LOGFORMAT = "%(asctime)s:%(levelname)s:%(module)s:%(message)s" + + +class TwwSettingsDialog(QDialog, DIALOG_UI): + settings = QSettings() + + def __init__(self, parent=None): + QDialog.__init__(self, parent) + self.setupUi(self) + + project = QgsProject.instance() + + svgprofile_path = self.settings.value("/TWW/SvgProfilePath", None) + if svgprofile_path: + self.mGbOverrideDefaultProfileTemplate.setChecked(True) + self.mProfileTemplateFile.setText(svgprofile_path) + else: + self.mGbOverrideDefaultProfileTemplate.setChecked(False) + + develmode = self.settings.value("/TWW/DeveloperMode", False, type=bool) + self.mCbDevelMode.setChecked(develmode) + + adminmode = self.settings.value("/TWW/AdminMode", False, type=bool) + self.mCbAdminMode.setChecked(adminmode) + + lyr_special_structures, _ = project.readEntry("TWW", "SpecialStructureLayer") + lyr_graph_edges, _ = project.readEntry("TWW", "GraphEdgeLayer") + lyr_graph_nodes, _ = project.readEntry("TWW", "GraphNodeLayer") + + self.initLayerCombobox(self.mCbSpecialStructures, lyr_special_structures) + self.initLayerCombobox(self.mCbGraphEdges, lyr_graph_edges) + self.initLayerCombobox(self.mCbGraphNodes, lyr_graph_nodes) + + self.mCurrentProfileColorButton.setColor( + QColor(self.settings.value("/TWW/CurrentProfileColor", "#FF9500")) + ) + self.mHelperLineColorButton.setColor( + QColor(self.settings.value("/TWW/HelperLineColor", "#FFD900")) + ) + self.mHighlightColorButton.setColor( + QColor(self.settings.value("/TWW/HighlightColor", "#40FF40")) + ) + + self.mPbnChooseProfileTemplateFile.clicked.connect(self.onChooseProfileTemplateFileClicked) + self.mPbnChooseLogFile.clicked.connect(self.onChooseLogFileClicked) + + self.accepted.connect(self.onAccept) + + loglevel = self.settings.value("/TWW/LogLevel", "Warning") + self.mCbLogLevel.setCurrentIndex(self.mCbLogLevel.findText(self.tr(loglevel))) + + logfile = self.settings.value("/TWW/LogFile", None) + + if logfile is not None: + self.mGbLogToFile.setChecked(True) + self.mLogFile.setText(logfile) + else: + self.mGbLogToFile.setChecked(False) + + def initLayerCombobox(self, combobox, default): + reg = QgsProject.instance() + for key, layer in list(reg.mapLayers().items()): + combobox.addItem(layer.name(), key) + + idx = combobox.findData(default) + if idx != -1: + combobox.setCurrentIndex(idx) + + @pyqtSlot() + def onAccept(self): + twwlogger = logging.getLogger("tww") + # General settings + if self.mGbOverrideDefaultProfileTemplate.isChecked() and self.mProfileTemplateFile.text(): + self.settings.setValue("/TWW/SvgProfilePath", self.mProfileTemplateFile.text()) + else: + self.settings.remove("/TWW/SvgProfilePath") + + self.settings.setValue("/TWW/DeveloperMode", self.mCbDevelMode.isChecked()) + self.settings.setValue("/TWW/AdminMode", self.mCbAdminMode.isChecked()) + + # Logging + if hasattr(twwlogger, "twwFileHandler"): + twwlogger.removeHandler(twwlogger.twwFileHandler) + del twwlogger.twwFileHandler + + if self.mGbLogToFile.isChecked(): + logfile = str(self.mLogFile.text()) + log_handler = logging.FileHandler(logfile) + fmt = logging.Formatter(LOGFORMAT) + log_handler.setFormatter(fmt) + twwlogger.addHandler(log_handler) + twwlogger.twwFileHandler = log_handler + self.settings.setValue("/TWW/LogFile", logfile) + else: + self.settings.setValue("/TWW/LogFile", None) + + if self.tr("Debug") == self.mCbLogLevel.currentText(): + twwlogger.setLevel(logging.DEBUG) + self.settings.setValue("/TWW/LogLevel", "Debug") + elif self.tr("Info") == self.mCbLogLevel.currentText(): + twwlogger.setLevel(logging.INFO) + self.settings.setValue("/TWW/LogLevel", "Info") + elif self.tr("Warning") == self.mCbLogLevel.currentText(): + twwlogger.setLevel(logging.WARNING) + self.settings.setValue("/TWW/LogLevel", "Warning") + elif self.tr("Error") == self.mCbLogLevel.currentText(): + twwlogger.setLevel(logging.ERROR) + self.settings.setValue("/TWW/LogLevel", "Error") + + # Save colors + self.settings.setValue("/TWW/HelperLineColor", self.mHelperLineColorButton.color().name()) + self.settings.setValue("/TWW/HighlightColor", self.mHighlightColorButton.color().name()) + self.settings.setValue( + "/TWW/CurrentProfileColor", self.mCurrentProfileColorButton.color().name() + ) + + # Project specific settings + project = QgsProject.instance() + + specialstructure_idx = self.mCbSpecialStructures.currentIndex() + graph_edgelayer_idx = self.mCbGraphEdges.currentIndex() + graph_nodelayer_idx = self.mCbGraphNodes.currentIndex() + + project.writeEntry( + "TWW", + "SpecialStructureLayer", + self.mCbSpecialStructures.itemData(specialstructure_idx), + ) + project.writeEntry( + "TWW", "GraphEdgeLayer", self.mCbGraphEdges.itemData(graph_edgelayer_idx) + ) + project.writeEntry( + "TWW", "GraphNodeLayer", self.mCbGraphNodes.itemData(graph_nodelayer_idx) + ) + + @pyqtSlot() + def onChooseProfileTemplateFileClicked(self): + filename, __ = QFileDialog.getOpenFileName( + self, + self.tr("Select profile template"), + "", + self.tr("HTML files(*.htm *.html)"), + ) + self.mProfileTemplateFile.setText(filename) + + @pyqtSlot() + def onChooseLogFileClicked(self): + filename, __ = QFileDialog.getSaveFileName( + self, self.tr("Select log file"), "", self.tr("Log files(*.log)") + ) + self.mLogFile.setText(filename) diff --git a/plugin/teksi_wastewater/gui/twwwizard.py b/plugin/teksi_wastewater/gui/twwwizard.py new file mode 100644 index 000000000..a41369f9a --- /dev/null +++ b/plugin/teksi_wastewater/gui/twwwizard.py @@ -0,0 +1,95 @@ +# ----------------------------------------------------------- +# +# TEKSI Wastewater +# Copyright (C) 2014 Matthias Kuhn +# ----------------------------------------------------------- +# +# licensed under the terms of GNU GPL 2 +# +# 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. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, print to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# --------------------------------------------------------------------- + +import logging + +from qgis.PyQt.QtCore import pyqtSlot +from qgis.PyQt.QtWidgets import QDockWidget + +from ..tools.twwmaptooladdfeature import TwwMapToolAddReach +from ..utils import get_ui_class +from ..utils.twwlayermanager import TwwLayerManager + +DOCK_WIDGET = get_ui_class("twwwizard.ui") + + +class TwwWizard(QDockWidget, DOCK_WIDGET): + logger = logging.getLogger(__name__) + + def __init__(self, parent, iface): + QDockWidget.__init__(self, parent) + self.setupUi(self) + self.layerComboBox.currentIndexChanged.connect(self.layerChanged) + self.stateButton.clicked.connect(self.stateChanged) + self.iface = iface + self.layerComboBox.insertItem( + self.layerComboBox.count(), + self.tr("Wastewater Structure"), + "wastewater_structure", + ) + self.layerComboBox.insertItem(self.layerComboBox.count(), self.tr("Reach"), "reach") + self.stateButton.setProperty("state", "inactive") + + self.mapToolAddReach = TwwMapToolAddReach( + self.iface, TwwLayerManager.layer("vw_tww_reach") + ) + + @pyqtSlot(int) + def layerChanged(self, index): + for lyr in [ + TwwLayerManager.layer("vw_tww_wastewater_structure"), + TwwLayerManager.layer("vw_tww_reach"), + ]: + lyr.commitChanges() + + if ( + self.layerComboBox.itemData(self.layerComboBox.currentIndex()) + == "wastewater_structure" + ): + lyr = TwwLayerManager.layer("vw_tww_wastewater_structure") + lyr.startEditing() + self.iface.setActiveLayer(lyr) + self.iface.actionAddFeature().trigger() + + elif self.layerComboBox.itemData(self.layerComboBox.currentIndex()) == "reach": + lyr = TwwLayerManager.layer("vw_tww_reach") + lyr.startEditing() + self.iface.mapCanvas().setMapTool(self.mapToolAddReach) + + @pyqtSlot() + def stateChanged(self): + if self.stateButton.property("state") != "active": + self.layerComboBox.setEnabled(True) + self.layerChanged(0) + self.stateButton.setText(self.tr("Stop Data Entry")) + self.stateButton.setProperty("state", "active") + else: + for lyr in [ + TwwLayerManager.layer("vw_tww_reach"), + TwwLayerManager.layer("vw_tww_wastewater_structure"), + ]: + lyr.commitChanges() + self.layerComboBox.setEnabled(False) + self.stateButton.setText(self.tr("Start Data Entry")) + self.stateButton.setProperty("state", "inactive") diff --git a/plugin/teksi_wastewater/icons/interlis_export.svg b/plugin/teksi_wastewater/icons/interlis_export.svg new file mode 100644 index 000000000..561775c95 --- /dev/null +++ b/plugin/teksi_wastewater/icons/interlis_export.svg @@ -0,0 +1,103 @@ + + + + + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/interlis_import.svg b/plugin/teksi_wastewater/icons/interlis_import.svg new file mode 100644 index 000000000..3dd3fe172 --- /dev/null +++ b/plugin/teksi_wastewater/icons/interlis_import.svg @@ -0,0 +1,91 @@ + + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/link-wastewater-networkelement.svg b/plugin/teksi_wastewater/icons/link-wastewater-networkelement.svg new file mode 100644 index 000000000..4ed1c9112 --- /dev/null +++ b/plugin/teksi_wastewater/icons/link-wastewater-networkelement.svg @@ -0,0 +1,198 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/newproject.svg b/plugin/teksi_wastewater/icons/newproject.svg new file mode 100644 index 000000000..854eb12fa --- /dev/null +++ b/plugin/teksi_wastewater/icons/newproject.svg @@ -0,0 +1,159 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/refresh-network.svg b/plugin/teksi_wastewater/icons/refresh-network.svg new file mode 100644 index 000000000..7c8dd6a52 --- /dev/null +++ b/plugin/teksi_wastewater/icons/refresh-network.svg @@ -0,0 +1,211 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + SQL + + + + + diff --git a/plugin/teksi_wastewater/icons/teksi-abwasser-logo.svg b/plugin/teksi_wastewater/icons/teksi-abwasser-logo.svg new file mode 100644 index 000000000..d3af21e5d --- /dev/null +++ b/plugin/teksi_wastewater/icons/teksi-abwasser-logo.svg @@ -0,0 +1,55 @@ + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/twwIcon.png b/plugin/teksi_wastewater/icons/twwIcon.png new file mode 100644 index 000000000..aad5864cf Binary files /dev/null and b/plugin/teksi_wastewater/icons/twwIcon.png differ diff --git a/plugin/teksi_wastewater/icons/twwIcon.svg b/plugin/teksi_wastewater/icons/twwIcon.svg new file mode 100644 index 000000000..66c5cabe0 --- /dev/null +++ b/plugin/teksi_wastewater/icons/twwIcon.svg @@ -0,0 +1,473 @@ + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + style="overflow:visible"> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/wastewater-downstream.svg b/plugin/teksi_wastewater/icons/wastewater-downstream.svg new file mode 100644 index 000000000..b9426bb7c --- /dev/null +++ b/plugin/teksi_wastewater/icons/wastewater-downstream.svg @@ -0,0 +1,2389 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/wastewater-profile.svg b/plugin/teksi_wastewater/icons/wastewater-profile.svg new file mode 100644 index 000000000..daccc5051 --- /dev/null +++ b/plugin/teksi_wastewater/icons/wastewater-profile.svg @@ -0,0 +1,154 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/wastewater-upstream.svg b/plugin/teksi_wastewater/icons/wastewater-upstream.svg new file mode 100644 index 000000000..d84cc3c60 --- /dev/null +++ b/plugin/teksi_wastewater/icons/wastewater-upstream.svg @@ -0,0 +1,2389 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/icons/wizard.svg b/plugin/teksi_wastewater/icons/wizard.svg new file mode 100644 index 000000000..1f2e0fc85 --- /dev/null +++ b/plugin/teksi_wastewater/icons/wizard.svg @@ -0,0 +1,253 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + diff --git a/plugin/teksi_wastewater/interlis/config.py b/plugin/teksi_wastewater/interlis/config.py new file mode 100644 index 000000000..068190a4f --- /dev/null +++ b/plugin/teksi_wastewater/interlis/config.py @@ -0,0 +1,21 @@ +import os + +BASE = os.path.dirname(__file__) + +PGSERVICE = None # overriden by PG* settings below +PGHOST = os.getenv("PGHOST", None) +PGPORT = os.getenv("PGPORT", None) +PGDATABASE = os.getenv("PGDATABASE", None) +PGUSER = os.getenv("PGUSER", None) +PGPASS = os.getenv("PGPASS", None) + +ILIVALIDATOR = os.path.join(BASE, "bin", "ilivalidator-1.11.9", "ilivalidator-1.11.9.jar") + +TWW_DEFAULT_PGSERVICE = "pg_tww" +TWW_OD_SCHEMA = "tww_od" +TWW_VL_SCHEMA = "tww_vl" +ABWASSER_SCHEMA = "pg2ili_abwasser" +MODEL_NAME_VSA_KEK = "VSA_KEK_2020_1_LV95" +MODEL_NAME_SIA405_ABWASSER = "SIA405_ABWASSER_2020_1_LV95" +MODEL_NAME_SIA405_BASE_ABWASSER = "SIA405_Base_Abwasser_1_LV95" +MODEL_NAME_DSS = "DSS_2020_1_LV95" diff --git a/plugin/teksi_wastewater/interlis/gui/__init__.py b/plugin/teksi_wastewater/interlis/gui/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/plugin/teksi_wastewater/interlis/gui/editors/__init__.py b/plugin/teksi_wastewater/interlis/gui/editors/__init__.py new file mode 100644 index 000000000..10af2901d --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/editors/__init__.py @@ -0,0 +1,25 @@ +import importlib +import pkgutil + + +def import_submodules(package, recursive=True): + """Import all submodules of a module, recursively, including subpackages + + :param package: package (name or actual module) + :type package: str | module + :rtype: dict[str, types.ModuleType] + + Taken from https://stackoverflow.com/a/25562415/13690651 + """ + if isinstance(package, str): + package = importlib.import_module(package) + results = {} + for loader, name, is_pkg in pkgutil.walk_packages(package.__path__): + full_name = package.__name__ + "." + name + results[full_name] = importlib.import_module(full_name) + if recursive and is_pkg: + results.update(import_submodules(full_name)) + return results + + +import_submodules(__name__) diff --git a/plugin/teksi_wastewater/interlis/gui/editors/base.py b/plugin/teksi_wastewater/interlis/gui/editors/base.py new file mode 100644 index 000000000..bed275a44 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/editors/base.py @@ -0,0 +1,155 @@ +import os +from collections import defaultdict + +from qgis.PyQt.QtCore import Qt +from qgis.PyQt.QtGui import QBrush, QColor +from qgis.PyQt.QtWidgets import QTreeWidgetItem, QWidget +from qgis.PyQt.uic import loadUi +from sqlalchemy import inspect + + +class Editor: + """ + Base class to manage import options for TWW classes. + + Editor subclasses are responsible of: + - managing a listwidgetitem + - providing a widget to edit options + - change the current session objects according to widget interaction + - validate objects according to the current session + """ + + # Validity + INVALID = "INVALID" + UNKNOWN = "UNKNOWN" + WARNING = "WARNING" + VALID = "VALID" + + # State + NEW = "NEW" + DELETED = "DELETED" + MODIFIED = "MODIFIED" + EXISTING = "EXISTING" + + class_name = "base" + widget_name = "base.ui" + + registry = defaultdict(lambda: Editor) + + def __init_subclass__(cls): + """ + Populates Editor.registry + """ + Editor.registry[cls.class_name] = cls + + @staticmethod + def factory(main_dialog, session, obj): + """ + Creates an Editor instance, choosing the correct subclass from the registry + """ + editor_class = Editor.registry[obj.__class__.__name__] + return editor_class(main_dialog, session, obj) + + def __init__(self, main_dialog, session, obj): + self.main_dialog = main_dialog + self.session = session + self.obj = obj + + self.preprocess() + + self.update_state() + + @property + def listitem(self): + """ + The editor's listitem (created on the fly if needed) + """ + if not hasattr(self, "_listitem"): + self._listitem = QTreeWidgetItem() + self._listitem.setCheckState( + 0, Qt.Checked if self.initially_checked() else Qt.Unchecked + ) + self.update_listitem() + return self._listitem + + def update_listitem(self): + disp_id = str( + getattr(self.obj, "obj_id", getattr(self.obj, "value_en", "?")) + ) # some elements may not have obj_id, such as value_lists + self.listitem.setText(0, getattr(self.obj, "identifier", disp_id)) + self.listitem.setToolTip(0, disp_id) + + self.listitem.setText(1, self.status) + + self.listitem.setText(2, self.validity) + if self.status == Editor.EXISTING: + color = "lightgray" + elif self.validity == Editor.INVALID: + color = "red" + elif self.validity == Editor.WARNING: + color = "orange" + elif self.validity == Editor.VALID: + color = "lightgreen" + else: + color = "lightgray" + self.listitem.setBackground(2, QBrush(QColor(color))) + + @property + def widget(self): + """ + The editor's widget (created on the fly if needed) + """ + if not hasattr(self, "_widget"): + + class BaseWidget(QWidget): + pass + + self._widget = BaseWidget() + loadUi(os.path.join(os.path.dirname(__file__), self.widget_name), self._widget) + self.init_widget() + return self._widget + + def preprocess(self): + """ + Run some preprocessing steps (such as auto-assigning data)... To be overriden by subclasses. + """ + + def init_widget(self): + """ + Initialize the widget here, for things like connecting signals... To be overriden by subclasses. + """ + + def update_widget(self): + """ + Update the widget here, for things like repopulating from session... To be overriden by subclasses. + """ + + def update_state(self): + """ + Updates status and calls validate. Call this when the underlying object may have changed. + """ + obj_inspect = inspect(self.obj) + if obj_inspect.pending: + self.status = Editor.NEW + elif obj_inspect.deleted: + self.status = Editor.DELETED + elif obj_inspect.modified: + self.status = Editor.MODIFIED + elif obj_inspect.persistent: + self.status = Editor.EXISTING + else: + self.status = Editor.UNKNOWN + self.validate() + + def validate(self): + """ + Updates validity and message. To be overriden by subclasses. You should probably call update_state if you need to revalidate. + """ + self.validity = Editor.VALID + self.message = "No validity check" + + def initially_checked(self): + """ + Determines if the item must be initially checked. To be overriden by subclasses. + """ + return True diff --git a/plugin/teksi_wastewater/interlis/gui/editors/base.ui b/plugin/teksi_wastewater/interlis/gui/editors/base.ui new file mode 100644 index 000000000..c7993003c --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/editors/base.ui @@ -0,0 +1,31 @@ + + + Form + + + + 0 + 0 + 400 + 300 + + + + Form + + + + + + No import options + + + Qt::AlignCenter + + + + + + + + diff --git a/plugin/teksi_wastewater/interlis/gui/editors/damage_channel.py b/plugin/teksi_wastewater/interlis/gui/editors/damage_channel.py new file mode 100644 index 000000000..0bdcf0e98 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/editors/damage_channel.py @@ -0,0 +1,17 @@ +from .base import Editor + + +class DamageChannelEditor(Editor): + class_name = "damage_channel" + + # DISABLED FOR NOW AS PER https://github.com/TWW/tww2ili/issues/8 + # this would allow to deselect BCD inspections (start of inspection) by default, + # as they don't provide valuable information. Once consensus is reached, we + # can remove this Editor altogether. + # def initially_checked(self): + # """ + # Determines if the item must be initially checked. To be overriden by subclasses. + # """ + # if self.obj.channel_damage_code__REL.value_en == "BCD": + # return False + # return True diff --git a/plugin/teksi_wastewater/interlis/gui/editors/data_media.py b/plugin/teksi_wastewater/interlis/gui/editors/data_media.py new file mode 100644 index 000000000..cb03ee223 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/editors/data_media.py @@ -0,0 +1,41 @@ +import os + +from .base import Editor + + +class DataMediaEditor(Editor): + class_name = "data_media" + widget_name = "data_media.ui" + + def __init__(self, *args, **kwargs): + self._path_was_changed = False + super().__init__(*args, **kwargs) + + def init_widget(self): + self.widget.pushButton.pressed.connect(lambda: self.button_clicked()) + self.update_widget() + + def update_widget(self): + self.widget.lineEdit.setText(self.obj.path) + + def button_clicked(self): + self.obj.path = self.widget.lineEdit.text() + self._path_was_changed = True + + self.update_state() + self.main_dialog.refresh_editor(self) + self.main_dialog.update_tree() + + def validate(self): + if not self._path_was_changed: + self.validity = Editor.WARNING + self.message = "Path was not adapted." + elif not os.path.exists(self.obj.path): + self.validity = Editor.WARNING + self.message = "This path does not exist on the current system" + elif not os.path.isdir(self.obj.path): + self.validity = Editor.WARNING + self.message = "This path is not a directory" + else: + self.validity = Editor.VALID + self.message = "No warning" diff --git a/plugin/teksi_wastewater/interlis/gui/editors/data_media.ui b/plugin/teksi_wastewater/interlis/gui/editors/data_media.ui new file mode 100644 index 000000000..1722c071f --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/editors/data_media.ui @@ -0,0 +1,48 @@ + + + Form + + + + 0 + 0 + 400 + 300 + + + + Form + + + + + + + + + + + Set + + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + diff --git a/plugin/teksi_wastewater/interlis/gui/featureselectorwidget.py b/plugin/teksi_wastewater/interlis/gui/featureselectorwidget.py new file mode 100644 index 000000000..068695af7 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/featureselectorwidget.py @@ -0,0 +1,236 @@ +# ----------------------------------------------------------- +# +# QGIS wincan 2 TWW Plugin +# Copyright (C) 2016 Denis Rouzaud +# +# ----------------------------------------------------------- +# +# licensed under the terms of GNU GPL 2 +# +# 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. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# --------------------------------------------------------------------- + + +from qgis.core import ( + Qgis, + QgsApplication, + QgsExpression, + QgsExpressionContext, + QgsExpressionContextScope, + QgsFeature, +) +from qgis.gui import QgsHighlight, QgsMapToolIdentifyFeature +from qgis.PyQt.QtCore import QSettings, QTimer, pyqtSignal, pyqtSlot +from qgis.PyQt.QtGui import QColor +from qgis.PyQt.QtWidgets import QAction, QHBoxLayout, QLineEdit, QToolButton, QWidget + + +class CanvasExtent: + Fixed = 1 + Pan = 2 + Scale = 3 + + +class FeatureSelectorWidget(QWidget): + feature_identified = pyqtSignal(QgsFeature) + + def __init__(self, parent): + QWidget.__init__(self, parent) + + edit_layout = QHBoxLayout() + edit_layout.setContentsMargins(0, 0, 0, 0) + edit_layout.setSpacing(2) + self.setLayout(edit_layout) + + self.line_edit = QLineEdit(self) + self.line_edit.setReadOnly(True) + edit_layout.addWidget(self.line_edit) + + self.highlight_feature_button = QToolButton(self) + self.highlight_feature_button.setPopupMode(QToolButton.MenuButtonPopup) + self.highlight_feature_action = QAction( + QgsApplication.getThemeIcon("/mActionHighlightFeature.svg"), "Highlight feature", self + ) + self.scale_highlight_feature_action = QAction( + QgsApplication.getThemeIcon("/mActionScaleHighlightFeature.svg"), + "Scale and highlight feature", + self, + ) + self.pan_highlight_feature_action = QAction( + QgsApplication.getThemeIcon("/mActionPanHighlightFeature.svg"), + "Pan and highlight feature", + self, + ) + self.highlight_feature_button.addAction(self.highlight_feature_action) + self.highlight_feature_button.addAction(self.scale_highlight_feature_action) + self.highlight_feature_button.addAction(self.pan_highlight_feature_action) + self.highlight_feature_button.setDefaultAction(self.highlight_feature_action) + edit_layout.addWidget(self.highlight_feature_button) + + self.map_identification_button = QToolButton(self) + self.map_identification_button.setIcon( + QgsApplication.getThemeIcon("/mActionMapIdentification.svg") + ) + self.map_identification_button.setText("Select on map") + self.map_identification_button.setCheckable(True) + edit_layout.addWidget(self.map_identification_button) + + self.map_identification_button.clicked.connect(self.map_identification) + self.highlight_feature_button.triggered.connect(self.highlight_action_triggered) + + self.layer = None + self.map_tool = None + self.canvas = None + self.window_widget = None + self.highlight = None + self.feature = QgsFeature() + + def set_canvas(self, map_canvas): + self.map_tool = QgsMapToolIdentifyFeature(map_canvas) + self.map_tool.setButton(self.map_identification_button) + self.canvas = map_canvas + + def set_layer(self, layer): + self.layer = layer + + def set_feature(self, feature, canvas_extent=CanvasExtent.Fixed): + self.line_edit.clear() + self.feature = feature + + if self.feature is None or not self.feature.isValid() or self.layer is None: + return + + expression = QgsExpression(self.layer.displayExpression()) + context = QgsExpressionContext() + scope = QgsExpressionContextScope() + context.appendScope(scope) + scope.setFeature(feature) + feature_title = expression.evaluate(context) + if feature_title == "": + feature_title = feature.id() + self.line_edit.setText(str(feature_title)) + self.highlight_feature(canvas_extent) + + def clear(self): + self.feature = QgsFeature() + self.line_edit.clear() + + @pyqtSlot() + def map_identification(self): + if self.layer is None or self.map_tool is None or self.canvas is None: + return + + self.map_tool.setLayer(self.layer) + self.canvas.setMapTool(self.map_tool) + + self.window_widget = QWidget.window(self) + self.canvas.window().raise_() + self.canvas.activateWindow() + self.canvas.setFocus() + + self.map_tool.featureIdentified.connect(self.map_tool_feature_identified) + self.map_tool.deactivated.connect(self.map_tool_deactivated) + + def map_tool_feature_identified(self, feature): + feature = QgsFeature(feature) + self.feature_identified.emit(feature) + self.unset_map_tool() + self.set_feature(feature) + + def map_tool_deactivated(self): + if self.window_widget is not None: + self.window_widget.raise_() + self.window_widget.activateWindow() + + def highlight_feature(self, canvas_extent=CanvasExtent.Fixed): + if self.canvas is None or not self.feature.isValid(): + return + + geom = self.feature.geometry() + + if geom is None: + return + + if canvas_extent == CanvasExtent.Scale: + feature_bounding_box = geom.boundingBox() + feature_bounding_box = self.canvas.mapSettings().layerToMapCoordinates( + self.layer, feature_bounding_box + ) + extent = self.canvas.extent() + if not extent.contains(feature_bounding_box): + extent.combineExtentWith(feature_bounding_box) + extent.scale(1.1) + self.canvas.setExtent(extent) + self.canvas.refresh() + + elif canvas_extent == CanvasExtent.Pan: + centroid = geom.centroid() + center = centroid.asPoint() + + center = self.canvas.mapSettings().layerToMapCoordinates(self.layer, center) + self.canvas.zoomByFactor(1.0, center) # refresh is done in this method + + # highlight + self.delete_highlight() + self.highlight = QgsHighlight(self.canvas, geom, self.layer) + + settings = QSettings() + color = QColor(settings.value("/Map/highlight/color", Qgis.DEFAULT_HIGHLIGHT_COLOR.name())) + alpha = int( + settings.value("/Map/highlight/colorAlpha", Qgis.DEFAULT_HIGHLIGHT_COLOR.alpha()) + ) + buffer = 2 * float( + settings.value("/Map/highlight/buffer", Qgis.DEFAULT_HIGHLIGHT_BUFFER_MM) + ) + min_width = 2 * float( + settings.value("/Map/highlight/min_width", Qgis.DEFAULT_HIGHLIGHT_MIN_WIDTH_MM) + ) + + self.highlight.setColor(color) # sets also fill with default alpha + color.setAlpha(alpha) + self.highlight.setFillColor(color) # sets fill with alpha + self.highlight.setBuffer(buffer) + self.highlight.setMinWidth(min_width) + self.highlight.setWidth(4.0) + self.highlight.show() + + self.timer = QTimer(self) + self.timer.setSingleShot(True) + self.timer.timeout.connect(self.delete_highlight) + self.timer.start(3000) + + def delete_highlight(self): + if self.highlight is not None: + self.highlight.hide() + del self.highlight + self.highlight = None + + def unset_map_tool(self): + if self.canvas is not None and self.map_tool is not None: + # this will call mapTool.deactivated + self.canvas.unsetMapTool(self.map_tool) + + def highlight_action_triggered(self, action): + self.highlight_feature_button.setDefaultAction(action) + + if action == self.highlight_feature_action: + self.highlight_feature() + + elif action == self.scale_highlight_feature_action: + self.highlight_feature(CanvasExtent.Scale) + + elif action == self.pan_highlight_feature_action: + self.highlight_feature(CanvasExtent.Pan) diff --git a/plugin/teksi_wastewater/interlis/gui/interlis_export_settings_dialog.py b/plugin/teksi_wastewater/interlis/gui/interlis_export_settings_dialog.py new file mode 100644 index 000000000..c762c567e --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/interlis_export_settings_dialog.py @@ -0,0 +1,108 @@ +import os +from collections import OrderedDict + +from qgis.core import Qgis, QgsSettings +from qgis.PyQt.QtWidgets import QCheckBox, QDialog +from qgis.PyQt.uic import loadUi + +from ...utils.twwlayermanager import TwwLayerManager +from .. import config +from ..processing_algs.extractlabels_interlis import ExtractlabelsInterlisAlgorithm + + +class InterlisExportSettingsDialog(QDialog): + def __init__(self, parent): + super().__init__(parent) + loadUi(os.path.join(os.path.dirname(__file__), "interlis_export_settings_dialog.ui"), self) + + self.finished.connect(self.on_finish) + + # Fill models selection combobox + self.export_model_selection_comboBox.addItem( + config.MODEL_NAME_DSS, [config.MODEL_NAME_DSS] + ) + self.export_model_selection_comboBox.addItem( + config.MODEL_NAME_SIA405_ABWASSER, [config.MODEL_NAME_SIA405_ABWASSER] + ) + self.export_model_selection_comboBox.addItem( + config.MODEL_NAME_VSA_KEK, + [config.MODEL_NAME_VSA_KEK, config.MODEL_NAME_SIA405_ABWASSER], + ) + + structures_layer = TwwLayerManager.layer("vw_tww_wastewater_structure") + reaches_layer = TwwLayerManager.layer("vw_tww_reach") + self.structures = structures_layer.selectedFeatures() if structures_layer else [] + self.reaches = reaches_layer.selectedFeatures() if reaches_layer else [] + + self.limit_checkbox.setText( + f"Limit to selection ({len(self.structures)} structures and {len(self.reaches)} reaches)" + ) + + # Remember save next to file checkbox + settings_value = QgsSettings().value("tww_plugin/logs_next_to_file", False) + self.save_logs_next_to_file_checkbox.setChecked( + settings_value is True or settings_value == "true" + ) + + # Populate the labels list (restoring checked states of scaes) + selected_scales = QgsSettings().value("tww_plugin/last_selected_scales", "").split(",") + qgis_version_ok = Qgis.QGIS_VERSION_INT >= 32602 + self.labels_groupbox.setEnabled(qgis_version_ok) + self.labels_qgis_warning_label.setVisible(not qgis_version_ok) + self.scale_checkboxes = OrderedDict() + for scale_key, scale_disp, scale_val in ExtractlabelsInterlisAlgorithm.AVAILABLE_SCALES: + checkbox = QCheckBox(f"{scale_disp} [1:{scale_val}]") + checkbox.setChecked(qgis_version_ok and scale_key in selected_scales) + self.scale_checkboxes[scale_key] = checkbox + self.labels_groupbox.layout().addWidget(checkbox) + + def on_finish(self): + # Remember save next to file checkbox + QgsSettings().setValue("tww_plugin/logs_next_to_file", self.logs_next_to_file) + + # Save checked state of scales + if self.labels_groupbox.isChecked(): + selected_scales = [] + for key, checkbox in self.scale_checkboxes.items(): + if checkbox.isChecked(): + selected_scales.append(key) + QgsSettings().setValue("tww_plugin/last_selected_scales", ",".join(selected_scales)) + + @property + def logs_next_to_file(self): + return self.save_logs_next_to_file_checkbox.isChecked() + + @property + def selected_ids(self): + if self.limit_checkbox.isChecked(): + ids = [] + for struct in self.structures: + ids.append(str(struct["wn_obj_id"])) + for reach in self.reaches: + ids.append(str(reach["obj_id"])) + ids.append(str(reach["rp_from_fk_wastewater_networkelement"])) + ids.append(str(reach["rp_to_fk_wastewater_networkelement"])) + return ids + else: + return None + + @property + def limit_to_selection(self): + return self.limit_checkbox.isChecked() + + @property + def selected_labels_scales_indices(self): + if self.labels_groupbox.isChecked(): + scales = [] + for i, checkbox in enumerate(self.scale_checkboxes.values()): + if checkbox.isChecked(): + scales.append(i) + return scales + else: + return [] + + def selected_model(self): + return self.export_model_selection_comboBox.currentText() + + def selected_models(self): + return self.export_model_selection_comboBox.currentData() diff --git a/plugin/teksi_wastewater/interlis/gui/interlis_export_settings_dialog.ui b/plugin/teksi_wastewater/interlis/gui/interlis_export_settings_dialog.ui new file mode 100644 index 000000000..3478c3650 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/interlis_export_settings_dialog.ui @@ -0,0 +1,125 @@ + + + Dialog + + + + 0 + 0 + 381 + 175 + + + + + 0 + 0 + + + + TEKSI Wastewater Interlis export + + + + + + Export model selection + + + + + + + + + + + + + + Limit to selection + + + + + + + true + + + Export labels + + + true + + + + + + *{color: red; } + + + This feature requires QGIS 3.26.2 or newer. + + + + + + + + + + Save logs next to output + + + + + + + + + Qt::Horizontal + + + QDialogButtonBox::Cancel|QDialogButtonBox::Ok + + + + + + + + + buttonBox + accepted() + Dialog + accept() + + + 248 + 254 + + + 157 + 274 + + + + + buttonBox + rejected() + Dialog + reject() + + + 316 + 260 + + + 286 + 274 + + + + + diff --git a/plugin/teksi_wastewater/interlis/gui/interlis_import_selection_dialog.py b/plugin/teksi_wastewater/interlis/gui/interlis_import_selection_dialog.py new file mode 100644 index 000000000..67b3faa9b --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/interlis_import_selection_dialog.py @@ -0,0 +1,226 @@ +import os +import sys +from collections import defaultdict + +from qgis.core import Qgis +from qgis.PyQt.QtCore import Qt +from qgis.PyQt.QtGui import QFont +from qgis.PyQt.QtWidgets import QDialog, QHeaderView, QMessageBox, QTreeWidgetItem +from qgis.PyQt.uic import loadUi +from qgis.utils import iface +from sqlalchemy import inspect +from sqlalchemy.orm import Session + +from ...utils.qt_utils import OverrideCursor +from .editors.base import Editor + +# Required for loadUi to find the custom widget +sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..")) + + +class InterlisImportSelectionDialog(QDialog): + def __init__(self, parent=None): + super().__init__(parent) + loadUi( + os.path.join(os.path.dirname(__file__), "interlis_import_selection_dialog.ui"), self + ) + + self.accepted.connect(self.commit_session) + self.rejected.connect(self.rollback_session) + + header = self.treeWidget.header() + header.setSectionResizeMode(QHeaderView.ResizeToContents) + header.setSectionResizeMode(0, QHeaderView.Stretch) + + def init_with_session(self, session: Session): + """ + Shows the dialog with data from a session, and executes the dialog allowing to filter the rows to import + """ + self.session = session + + self.category_items = defaultdict(QTreeWidgetItem) # keys are instances' classes + self.editors = {} + + self.debugGroupBox.setChecked(False) + + self.treeWidget.clear() + self.update_tree() + + self.treeWidget.itemChanged.connect(self.item_changed) + self.treeWidget.currentItemChanged.connect(self.current_item_changed) + + def update_tree(self): + """ + Populates the tree, creating/updating items + """ + + for obj in self.session: + if obj not in self.editors: + self.editors[obj] = Editor.factory(self, self.session, obj) + editor = self.editors[obj] + + cls = obj.__class__ + + # Hide unmodified value lists items that may have been added to the session + if editor.status == Editor.EXISTING and cls.__table__.schema == "tww_vl": + continue + + if cls not in self.category_items: + self.category_items[cls].setText(0, cls.__name__) + self.category_items[cls].setCheckState(0, Qt.Checked) + self.category_items[cls].setFont( + 0, QFont(QFont().defaultFamily(), weight=QFont.Weight.Bold) + ) + self.treeWidget.addTopLevelItem(self.category_items[cls]) + + editor.update_listitem() + self.category_items[cls].addChild(editor.listitem) + + if editor.validity != Editor.VALID: + self.treeWidget.expandItem(self.category_items[cls]) + + # Show counts + for cls, category_item in self.category_items.items(): + category_item.setText(0, f"{cls.__name__} ({category_item.childCount()})") + + def item_changed(self, item, column): + """ + Adds or removes item's object from session. + + (propagation to parent/children is disabled for now) + """ + + checked = item.checkState(0) == Qt.Checked + + # add or remove object from session + obj = self.get_obj_from_listitem(item) + if obj is not None: + if checked: + self.session.add(obj) + else: + self.session.expunge(obj) + + checked_state = item.checkState(0) + if checked_state == Qt.PartiallyChecked: + return + + # propagate to children + for child in [item.child(i) for i in range(item.childCount())]: + child.setCheckState(0, checked_state) + + # propagate to parent + parent = item.parent() + if parent: + has_checked = False + has_unchecked = False + for sibling in [parent.child(i) for i in range(parent.childCount())]: + if sibling.checkState(0) == Qt.Checked: + has_checked = True + if sibling.checkState(0) == Qt.Unchecked: + has_unchecked = True + if has_checked and has_unchecked: + break + + if has_checked and has_unchecked: + parent.setCheckState(0, Qt.PartiallyChecked) + elif has_checked: + parent.setCheckState(0, Qt.Checked) + elif has_unchecked: + parent.setCheckState(0, Qt.Unchecked) + else: + # no children at all !! + parent.setCheckState(0, Qt.PartiallyChecked) + + def current_item_changed(self, current_item, previous_item): + """ + Calls refresh_widget_for_obj for the currently selected object + """ + for editor in self.editors.values(): + if editor.listitem == current_item: + self.refresh_editor(editor) + break + else: + self.debugTextEdit.clear() + self.validityLabel.clear() + current_widget = self.stackedWidget.currentWidget() + if current_widget: + self.stackedWidget.removeWidget(current_widget) + + def refresh_editor(self, editor): + """ + Refreshes the widget for the object, including validation, debug and status text + """ + # Revalidate the widget + editor.update_state() + + # Update the list item + editor.update_listitem() + + # Update generic widget contents + self.debugTextEdit.clear() + self.validityLabel.clear() + + # Show all attributes in the debug text edit + self.debugTextEdit.append("-- ATTRIBUTES --") + for c in inspect(editor.obj).mapper.column_attrs: + val = getattr(editor.obj, c.key) + self.debugTextEdit.append(f"{c.key}: {val}") + # Show sqlalchemy state in the debug text edit + self.debugTextEdit.append("-- SQLALCHEMY STATUS --") + for status_name in [ + "transient", + "pending", + "persistent", + "deleted", + "detached", + "modified", + "expired", + ]: + if getattr(inspect(editor.obj), status_name): + self.debugTextEdit.append(f"{status_name} ") + self.debugTextEdit.append("-- DEBUG --") + self.debugTextEdit.append(repr(editor.obj)) + + # Show the validity label + self.validityLabel.setText(editor.message) + if editor.validity == Editor.INVALID: + self.validityLabel.setStyleSheet("background-color: red; padding: 15px;") + elif editor.validity == Editor.WARNING: + self.validityLabel.setStyleSheet("background-color: orange; padding: 15px;") + elif editor.validity == Editor.VALID: + self.validityLabel.setStyleSheet("background-color: lightgreen; padding: 15px;") + else: + self.validityLabel.setStyleSheet("background-color: lightgray; padding: 15px;") + + # Update the actual widget + editor.update_widget() + + # Instantiate the specific widget (this has no effect if it's already active) + self.stackedWidget.addWidget(editor.widget) + self.stackedWidget.setCurrentWidget(editor.widget) + + def commit_session(self): + # TODO : rollback to pre-commit state, allowing user to try to fix issues + # probably a matter of creating a savepoint before saving with + # session.begin_nested() and one additionnal self.session.commit() + try: + with OverrideCursor(Qt.WaitCursor): + self.session.commit() + self.session.close() + except Exception as exception: + QMessageBox.critical(self, "Import error", f"Details: {exception}") + return + + iface.messageBar().pushMessage("Sucess", "Data successfully imported", level=Qgis.Success) + + def rollback_session(self): + with OverrideCursor(Qt.WaitCursor): + self.session.rollback() + self.session.close() + iface.messageBar().pushMessage("Error", "Import was canceled", level=Qgis.Warning) + + def get_obj_from_listitem(self, listitem): + for obj, editor in self.editors.items(): + if editor.listitem == listitem: + return obj + return None diff --git a/plugin/teksi_wastewater/interlis/gui/interlis_import_selection_dialog.ui b/plugin/teksi_wastewater/interlis/gui/interlis_import_selection_dialog.ui new file mode 100644 index 000000000..f3145e78b --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/interlis_import_selection_dialog.ui @@ -0,0 +1,249 @@ + + + Dialog + + + + 0 + 0 + 953 + 670 + + + + + 0 + 0 + + + + + 600 + 400 + + + + TWW interlis import + + + + + + Qt::Horizontal + + + + + 0 + 0 + + + + false + + + false + + + + name + + + + + state + + + + + validity + + + + + Inspections + + + + + + + + + + a + + + + + + + + + + + b + + + + + + + + + + + c + + + + + + + + + + + + Organisaitons + + + + + + + + + + a + + + + + + + + + + + b + + + + + + + + + + + c + + + + + + + + + + + + + + + + b + + + Unknown + + + true + + + 7 + + + + + + + + + + + + + Raw data (debug) + + + true + + + + + + + + + + + + + + + + Qt::Horizontal + + + QDialogButtonBox::Cancel|QDialogButtonBox::Ok + + + + + + + + QgsCollapsibleGroupBox + QGroupBox +
qgscollapsiblegroupbox.h
+ 1 + + + + + + buttonBox + accepted() + Dialog + accept() + + + 248 + 254 + + + 157 + 274 + + + + + buttonBox + rejected() + Dialog + reject() + + + 316 + 260 + + + 286 + 274 + + + + + diff --git a/plugin/teksi_wastewater/interlis/gui/interlis_importer_exporter_gui.py b/plugin/teksi_wastewater/interlis/gui/interlis_importer_exporter_gui.py new file mode 100644 index 000000000..ae7084866 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/gui/interlis_importer_exporter_gui.py @@ -0,0 +1,174 @@ +import os +import webbrowser + +from qgis.core import Qgis, QgsProject, QgsSettings +from qgis.PyQt.QtCore import QFileInfo, QObject, Qt +from qgis.PyQt.QtWidgets import QApplication, QFileDialog, QProgressDialog, QPushButton +from qgis.utils import iface + +from ...utils.qt_utils import OverrideCursor +from ..interlis_importer_exporter import ( + InterlisImporterExporter, + InterlisImporterExporterError, + InterlisImporterExporterStopped, +) +from .interlis_export_settings_dialog import InterlisExportSettingsDialog + + +class InterlisImporterExporterGui(QObject): + _PROGRESS_DIALOG_MINIMUM_WIDTH = 350 + + def __init__(self): + super().__init__(parent=None) + self.import_dialog = None + self.progress_dialog = None + + self.interlis_importer_exporter = InterlisImporterExporter( + progress_done_callback=self._progress_done_callback + ) + + def action_import(self): + """ + Is executed when the user clicks the importAction tool + """ + default_folder = QgsSettings().value( + "tww_plugin/last_interlis_path", QgsProject.instance().absolutePath() + ) + xtf_file_input, _ = QFileDialog.getOpenFileName( + None, + self.tr("Import file"), + default_folder, + self.tr("Interlis transfer files (*.xtf)"), + ) + if not xtf_file_input: + # Operation canceled + return + + QgsSettings().setValue("tww_plugin/last_interlis_path", os.path.dirname(xtf_file_input)) + + setting_value = QgsSettings().value("tww_plugin/logs_next_to_file", False) + logs_next_to_file = setting_value is True or setting_value == "true" + + self.progress_dialog = QProgressDialog("", "", 0, 100) + self.progress_dialog.setMinimumWidth(self._PROGRESS_DIALOG_MINIMUM_WIDTH) + self.progress_dialog.setCancelButtonText("Cancel") + self.progress_dialog.setMinimumDuration(0) + self.progress_dialog.setWindowTitle("Import Interlis data...") + + try: + with OverrideCursor(Qt.WaitCursor): + self.interlis_importer_exporter.interlis_import( + xtf_file_input, show_selection_dialog=True, logs_next_to_file=logs_next_to_file + ) + iface.mapCanvas().refreshAllLayers() + + except InterlisImporterExporterStopped: + self._cleanup() + iface.messageBar().pushMessage("Warning", "Import was canceled.", level=Qgis.Warning) + + except InterlisImporterExporterError as exception: + self._cleanup() + self.show_failure( + exception.error, + exception.additional_text, + exception.log_path, + ) + + except Exception as exception: + self._cleanup() + raise exception + + def action_export(self): + """ + Is executed when the user clicks the exportAction tool + """ + export_dialog = InterlisExportSettingsDialog(None) + + if export_dialog.exec_() == export_dialog.Rejected: + return + + default_folder = QgsSettings().value( + "tww_plugin/last_interlis_path", QgsProject.instance().absolutePath() + ) + file_name, _ = QFileDialog.getSaveFileName( + None, + self.tr("Export to file"), + os.path.join(default_folder, "tww-export.xtf"), + self.tr("Interlis transfer files (*.xtf)"), + ) + if not file_name: + # Operation canceled + return + QgsSettings().setValue("tww_plugin/last_interlis_path", os.path.dirname(file_name)) + + self.progress_dialog = QProgressDialog("", "", 0, 100) + self.progress_dialog.setMinimumWidth(self._PROGRESS_DIALOG_MINIMUM_WIDTH) + self.progress_dialog.setCancelButtonText("Cancel") + self.progress_dialog.setMinimumDuration(0) + self.progress_dialog.setWindowTitle("Export Interlis data...") + + try: + self.interlis_importer_exporter.interlis_export( + xtf_file_output=file_name, + export_models=export_dialog.selected_models(), + logs_next_to_file=export_dialog.logs_next_to_file, + limit_to_selection=export_dialog.limit_to_selection, + selected_labels_scales_indices=export_dialog.selected_labels_scales_indices, + selected_ids=export_dialog.selected_ids, + ) + + self.show_success( + "Success", + f"Data successfully exported to {QFileInfo(file_name).path()}", + None, + ) + + except InterlisImporterExporterStopped: + self._cleanup() + iface.messageBar().pushMessage("Warning", "Export was canceled.", level=Qgis.Warning) + + except InterlisImporterExporterError as exception: + self._cleanup() + self.show_failure( + exception.error, + exception.additional_text, + exception.log_path, + ) + + except Exception as exception: + self._cleanup() + raise exception + + def _progress_done_callback(self, progress, text=None): + self._check_for_canceled() + if text: + self.progress_dialog.setLabelText(text) + self.progress_dialog.setValue(progress) + QApplication.processEvents() + + def _show_results(self, title, message, log_path, level): + widget = iface.messageBar().createMessage(title, message) + if log_path: + button = QPushButton(widget) + button.setText("Show logs") + button.pressed.connect(lambda p=log_path: webbrowser.open(p)) + widget.layout().addWidget(button) + iface.messageBar().pushWidget(widget, level) + + def show_failure(self, title, message, log_path): + self._show_results(title, message, log_path, Qgis.Warning) + + def show_success(self, title, message, log_path): + self._show_results(title, message, log_path, Qgis.Success) + + def _check_for_canceled(self): + if self.progress_dialog.wasCanceled(): + raise InterlisImporterExporterStopped + + def _cleanup(self): + if self.progress_dialog: + self.progress_dialog.close() + + def _progress_done(self): + self._check_for_canceled() + self.progress_dialog.setValue(self.progress_dialog.value() + 1) diff --git a/plugin/teksi_wastewater/interlis/interlis_importer_exporter.py b/plugin/teksi_wastewater/interlis/interlis_importer_exporter.py new file mode 100644 index 000000000..317c60378 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_importer_exporter.py @@ -0,0 +1,456 @@ +import logging +import os +import tempfile + +import psycopg2 +from PyQt5.QtCore import Qt +from PyQt5.QtWidgets import QApplication + +from . import config +from .gui.interlis_import_selection_dialog import InterlisImportSelectionDialog +from .interlis_model_mapping.interlis_exporter_to_intermediate_schema import ( + InterlisExporterToIntermediateSchema, + InterlisExporterToIntermediateSchemaError, +) +from .interlis_model_mapping.interlis_importer_to_intermediate_schema import ( + InterlisImporterToIntermediateSchema, +) +from .interlis_model_mapping.model_interlis_dss import ModelInterlisDss +from .interlis_model_mapping.model_interlis_sia405_abwasser import ( + ModelInterlisSia405Abwasser, +) +from .interlis_model_mapping.model_interlis_vsa_kek import ModelInterlisVsaKek +from .interlis_model_mapping.model_tww_od import ModelTwwOd +from .interlis_model_mapping.model_tww_vl import ModelTwwVl +from .utils.ili2db import InterlisTools +from .utils.various import ( + CmdException, + LoggingHandlerContext, + get_pgconf_as_psycopg2_dsn, + logger, + make_log_path, +) + + +class InterlisImporterExporterStopped(Exception): + pass + + +class InterlisImporterExporterError(Exception): + def __init__(self, error, additional_text, log_path): + self.error = error + self.additional_text = additional_text + self.log_path = log_path + + +class InterlisImporterExporter: + def __init__(self, progress_done_callback=None): + self.progress_done_callback = progress_done_callback + self.interlisTools = InterlisTools() + self.base_log_path = None + + self.model_classes_interlis = None + self.model_classes_tww_od = None + self.model_classes_tww_vl = None + + self.current_progress = 0 + + def interlis_import(self, xtf_file_input, show_selection_dialog=False, logs_next_to_file=True): + # Configure logging + if logs_next_to_file: + self.base_log_path = xtf_file_input + else: + self.base_log_path = None + + # Validating the input file + self._progress_done(5, "Validating the input file...") + self._import_validate_xtf_file(xtf_file_input) + + # Get model to import from xtf file + self._progress_done(10, "Extract model from xtf...") + import_models = self.interlisTools.get_xtf_models(xtf_file_input) + + import_model = "" + if config.MODEL_NAME_VSA_KEK in import_models: + import_model = config.MODEL_NAME_VSA_KEK + elif config.MODEL_NAME_SIA405_ABWASSER in import_models: + import_model = config.MODEL_NAME_SIA405_ABWASSER + elif config.MODEL_NAME_DSS in import_models: + import_model = config.MODEL_NAME_DSS + elif config.MODEL_NAME_SIA405_BASE_ABWASSER in import_models: + import_model = config.MODEL_NAME_SIA405_ABWASSER + else: + error_text = f"No supported model was found among '{import_models}'." + if len(import_models) == 1: + error_text = f"The model '{import_models[0]}' is not supported." + raise InterlisImporterExporterError("Import error", error_text, None) + logger.info( + f"Model '{import_model}' was choosen for import among found models '{import_models}'" + ) + + # Prepare the temporary ili2pg model + self._progress_done(10, "Creating ili schema...") + self._clear_ili_schema(recreate_schema=True) + + self._progress_done(20) + self._create_ili_schema( + [import_model], ext_columns_no_constraints=True, create_basket_col=True + ) + + # Import from xtf file to ili2pg model + self._progress_done(40, "Importing XTF data...") + self._import_xtf_file(xtf_file_input=xtf_file_input) + + # Import from the temporary ili2pg model + self._progress_done(50, "Converting to Teksi Wastewater...") + tww_session = self._import_from_intermediate_schema(import_model) + + if show_selection_dialog: + self._progress_done(80, "Import objects selection...") + import_dialog = InterlisImportSelectionDialog() + import_dialog.init_with_session(tww_session) + QApplication.restoreOverrideCursor() + if import_dialog.exec_() == import_dialog.Rejected: + tww_session.rollback() + tww_session.close() + raise InterlisImporterExporterStopped() + QApplication.setOverrideCursor(Qt.WaitCursor) + else: + self._progress_done(80, "Commit session...") + tww_session.commit() + tww_session.close() + + # Update main_cover and main_wastewater_node + self._progress_done(90, "Update main cover and refresh materialized views...") + self._import_update_main_cover_and_refresh_mat_views() + + self._progress_done(100) + + def interlis_export( + self, + xtf_file_output, + export_models, + logs_next_to_file=True, + limit_to_selection=False, + selected_labels_scales_indices=[], + selected_ids=[], + ): + # File name without extension (used later for export) + file_name_base, _ = os.path.splitext(xtf_file_output) + + # Configure logging + if logs_next_to_file: + self.base_log_path = xtf_file_output + else: + self.base_log_path = None + + self._progress_done(5, "Clearing ili schema...") + self._clear_ili_schema(recreate_schema=True) + + self._progress_done(15, "Creating ili schema...") + create_basket_col = False + if config.MODEL_NAME_VSA_KEK in export_models: + create_basket_col = True + self._create_ili_schema(export_models, create_basket_col=create_basket_col) + + # Export the labels file + tempdir = tempfile.TemporaryDirectory() + labels_file_path = None + if len(selected_labels_scales_indices): + self._progress_done(25) + labels_file_path = os.path.join(tempdir.name, "labels.geojson") + self._export_labels_file( + limit_to_selection=limit_to_selection, + selected_labels_scales_indices=selected_labels_scales_indices, + labels_file_path=labels_file_path, + ) + + # Export to the temporary ili2pg model + self._progress_done(35, "Converting from Teksi Wastewater...") + self._export_to_intermediate_schema( + export_model=export_models[0], + file_name=xtf_file_output, + selected_ids=selected_ids, + labels_file_path=labels_file_path, + basket_enabled=create_basket_col, + ) + tempdir.cleanup() # Cleanup + + self._progress_done(60) + self._export_xtf_files(file_name_base, export_models) + + self._progress_done(100) + + def _import_validate_xtf_file(self, xtf_file_input): + log_path = make_log_path(self.base_log_path, "ilivalidator") + try: + self.interlisTools.validate_xtf_data( + xtf_file_input, + log_path, + ) + except CmdException: + raise InterlisImporterExporterError( + "Invalid file", + "The input file is not a valid XTF file. Open the logs for more details on the error.", + log_path, + ) + + def _import_xtf_file(self, xtf_file_input): + log_path = make_log_path(self.base_log_path, "ili2pg-import") + try: + self.interlisTools.import_xtf_data( + config.ABWASSER_SCHEMA, + xtf_file_input, + log_path, + ) + except CmdException: + raise InterlisImporterExporterError( + "Could not import data", + "Open the logs for more details on the error.", + log_path, + ) + + def _import_from_intermediate_schema(self, import_model): + log_handler = logging.FileHandler( + make_log_path(self.base_log_path, "tww2ili-import"), mode="w", encoding="utf-8" + ) + log_handler.setLevel(logging.INFO) + log_handler.setFormatter(logging.Formatter("%(levelname)-8s %(message)s")) + + self._init_model_classes(import_model) + + interlisImporterToIntermediateSchema = InterlisImporterToIntermediateSchema( + model=import_model, + model_classes_interlis=self.model_classes_interlis, + model_classes_tww_od=self.model_classes_tww_od, + model_classes_tww_vl=self.model_classes_tww_vl, + callback_progress_done=self._progress_done_intermediate_schema, + ) + + with LoggingHandlerContext(log_handler): + interlisImporterToIntermediateSchema.tww_import(skip_closing_tww_session=True) + + return interlisImporterToIntermediateSchema.session_tww + + def _import_update_main_cover_and_refresh_mat_views(self): + connection = psycopg2.connect(get_pgconf_as_psycopg2_dsn()) + connection.set_session(autocommit=True) + cursor = connection.cursor() + + logger.info("Update wastewater structure fk_main_cover") + cursor.execute("SELECT tww_app.wastewater_structure_update_fk_main_cover('', True);") + + logger.info("Update wastewater structure fk_main_wastewater_node") + cursor.execute( + "SELECT tww_app.wastewater_structure_update_fk_main_wastewater_node('', True);" + ) + + logger.info("Refresh materialized views") + cursor.execute("SELECT tww_app.network_refresh_network_simple();") + + connection.commit() + connection.close() + + def _export_labels_file( + self, limit_to_selection, selected_labels_scales_indices, labels_file_path + ): + self._progress_done(self.current_progress, "Extracting labels...") + + try: + # We only import now to avoid useless exception if dependencies aren't met + from qgis import processing + + from ..utils.twwlayermanager import TwwLayerManager + except ImportError: + raise InterlisImporterExporterError( + "Export labels error", + "Could not load export labels as qgis.processing module is not available.", + None, + ) + + structures_lyr = TwwLayerManager.layer("vw_tww_wastewater_structure") + reaches_lyr = TwwLayerManager.layer("vw_tww_reach") + if not structures_lyr or not reaches_lyr: + raise InterlisImporterExporterError( + "Could not find the vw_tww_wastewater_structure and/or the vw_tww_reach layers.", + "Make sure your Teksi Wastewater project is open.", + None, + ) + + self._progress_done(self.current_progress + 5) + processing.run( + "tww:extractlabels_interlis", + { + "OUTPUT": labels_file_path, + "RESTRICT_TO_SELECTION": limit_to_selection, + "STRUCTURE_VIEW_LAYER": structures_lyr, + "REACH_VIEW_LAYER": reaches_lyr, + "SCALES": selected_labels_scales_indices, + }, + ) + + def _export_to_intermediate_schema( + self, + export_model, + file_name=None, + selected_ids=None, + labels_file_path=None, + basket_enabled=False, + ): + log_handler = logging.FileHandler( + make_log_path(file_name, "tww2ili-export"), mode="w", encoding="utf-8" + ) + log_handler.setLevel(logging.INFO) + log_handler.setFormatter(logging.Formatter("%(levelname)-8s %(message)s")) + + self._init_model_classes(export_model) + + twwInterlisExporter = InterlisExporterToIntermediateSchema( + model=export_model, + model_classes_interlis=self.model_classes_interlis, + model_classes_tww_od=self.model_classes_tww_od, + model_classes_tww_vl=self.model_classes_tww_vl, + selection=selected_ids, + labels_file=labels_file_path, + basket_enabled=basket_enabled, + callback_progress_done=self._progress_done_intermediate_schema, + ) + + with LoggingHandlerContext(log_handler): + try: + twwInterlisExporter.tww_export() + except ( + InterlisExporterToIntermediateSchemaError + ) as interlisExporterToIntermediateSchemaError: + raise InterlisImporterExporterError( + "Could not export to the interlis schema", + f"{interlisExporterToIntermediateSchemaError}", + None, + ) + + def _export_xtf_files(self, file_name_base, export_models): + progress_step = (100 - self.current_progress) / (2 * len(export_models)) + progress_step = int(progress_step) + + xtf_export_errors = [] + for index, export_model_name in enumerate(export_models): + export_file_name = f"{file_name_base}_{export_model_name}.xtf" + + # Export from ili2pg model to file + self._progress_done(self.current_progress, f"Saving XTF for '{export_model_name}'...") + log_path = make_log_path(self.base_log_path, f"ili2pg-export-{export_model_name}") + try: + self.interlisTools.export_xtf_data( + schema=config.ABWASSER_SCHEMA, + xtf_file=export_file_name, + log_path=log_path, + model_name=export_model_name, + export_model_name=export_model_name, + ) + except CmdException: + xtf_export_errors.append( + InterlisImporterExporterError( + error=f"Could not export the model '{export_model_name}' from ili2pg schema", + additional_text="Open the logs for more details on the error.", + log_path=log_path, + ) + ) + continue + + self._progress_done( + self.current_progress + progress_step, + f"Validating XTF for '{export_model_name}'...", + ) + log_path = make_log_path(self.base_log_path, f"ilivalidator-{export_model_name}") + try: + self.interlisTools.validate_xtf_data( + export_file_name, + log_path, + ) + except CmdException: + xtf_export_errors.append( + InterlisImporterExporterError( + error=f"Validation of exported file '{export_file_name}' failed", + additional_text=f"The created file is not a valid {export_model_name} XTF file.", + log_path=log_path, + ) + ) + continue + + self._progress_done(self.current_progress + progress_step) + + # In case some export had an error raise the first one + if xtf_export_errors: + raise xtf_export_errors[0] + + def _clear_ili_schema(self, recreate_schema=False): + logger.info("CONNECTING TO DATABASE...") + + connection = psycopg2.connect(get_pgconf_as_psycopg2_dsn()) + connection.set_session(autocommit=True) + cursor = connection.cursor() + + if not recreate_schema: + # If the schema already exists, we just truncate all tables + cursor.execute( + f"SELECT schema_name FROM information_schema.schemata WHERE schema_name = '{config.ABWASSER_SCHEMA}';" + ) + if cursor.rowcount > 0: + logger.info(f"Schema {config.ABWASSER_SCHEMA} already exists, we truncate instead") + cursor.execute( + f"SELECT table_name FROM information_schema.tables WHERE table_schema = '{config.ABWASSER_SCHEMA}';" + ) + for row in cursor.fetchall(): + cursor.execute(f"TRUNCATE TABLE {config.ABWASSER_SCHEMA}.{row[0]} CASCADE;") + return + + logger.info(f"DROPPING THE SCHEMA {config.ABWASSER_SCHEMA}...") + cursor.execute(f'DROP SCHEMA IF EXISTS "{config.ABWASSER_SCHEMA}" CASCADE ;') + logger.info(f"CREATING THE SCHEMA {config.ABWASSER_SCHEMA}...") + cursor.execute(f'CREATE SCHEMA "{config.ABWASSER_SCHEMA}";') + connection.commit() + connection.close() + + def _create_ili_schema( + self, models, ext_columns_no_constraints=False, create_basket_col=False + ): + log_path = make_log_path(self.base_log_path, "ili2pg-schemaimport") + try: + self.interlisTools.import_ili_schema( + config.ABWASSER_SCHEMA, + models, + log_path, + ext_columns_no_constraints=ext_columns_no_constraints, + create_basket_col=create_basket_col, + ) + except CmdException: + raise InterlisImporterExporterError( + "Could not create the ili2pg schema", + "Open the logs for more details on the error.", + log_path, + ) + + def _init_model_classes(self, model): + ModelInterlis = ModelInterlisSia405Abwasser + if model == config.MODEL_NAME_DSS: + ModelInterlis = ModelInterlisDss + elif model == config.MODEL_NAME_VSA_KEK: + ModelInterlis = ModelInterlisVsaKek + self.model_classes_interlis = ModelInterlis().classes() + self._progress_done(self.current_progress + 1) + + if self.model_classes_tww_od is None: + self.model_classes_tww_od = ModelTwwOd().classes() + self._progress_done(self.current_progress + 1) + + if self.model_classes_tww_vl is None: + self.model_classes_tww_vl = ModelTwwVl().classes() + self._progress_done(self.current_progress + 1) + + def _progress_done_intermediate_schema(self): + self._progress_done(self.current_progress + 1) + + def _progress_done(self, progress, text=None): + self.current_progress = progress + if self.progress_done_callback: + self.progress_done_callback(progress, text) diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/__init__.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/interlis_exporter_to_intermediate_schema.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/interlis_exporter_to_intermediate_schema.py new file mode 100644 index 000000000..2aa7c72ce --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_model_mapping/interlis_exporter_to_intermediate_schema.py @@ -0,0 +1,1373 @@ +import json + +from geoalchemy2.functions import ST_Force2D, ST_GeomFromGeoJSON +from sqlalchemy import or_ +from sqlalchemy.orm import Session +from sqlalchemy.sql import text + +from .. import config, utils +from ..utils.various import logger + + +class InterlisExporterToIntermediateSchemaError(Exception): + pass + + +class InterlisExporterToIntermediateSchema: + def __init__( + self, + model, + model_classes_interlis, + model_classes_tww_od, + model_classes_tww_vl, + selection=None, + labels_file=None, + basket_enabled=False, + callback_progress_done=None, + ): + """ + Export data from the TWW model into the ili2pg model. + + Args: + selection: if provided, limits the export to networkelements that are provided in the selection + """ + self.model = model + self.callback_progress_done = callback_progress_done + + # Filtering + self.filtered = selection is not None + self.subset_ids = selection if selection is not None else [] + + self.labels_file = labels_file + + self.basket_enabled = basket_enabled + + self.model_classes_interlis = model_classes_interlis + self.model_classes_tww_od = model_classes_tww_od + self.model_classes_tww_vl = model_classes_tww_vl + + self.tww_session = None + self.abwasser_session = None + self.tid_maker = utils.ili2db.TidMaker(id_attribute="obj_id") + + def tww_export(self): + # Logging disabled (very slow) + self.tww_session = Session( + utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False + ) + self.abwasser_session = Session( + utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False + ) + + try: + self._export() + self.abwasser_session.commit() + self.close_sessions() + except Exception as exception: + self.close_sessions() + raise exception + + def _export(self): + # Allow to insert rows with cyclic dependencies at once + self.abwasser_session.execute(text("SET CONSTRAINTS ALL DEFERRED;")) + + if self.basket_enabled: + self.close_sessions() + raise InterlisExporterToIntermediateSchemaError( + "Export with baskets is not implemented (KEK export)" + ) + + self._export_sia405_abwasser() + + if self.model == config.MODEL_NAME_DSS: + self._export_dss() + + if self.model == config.MODEL_NAME_VSA_KEK: + self._export_vsa_kek() + + # Labels + # Note: these are extracted from the optional labels file (not exported from the TWW database) + if self.labels_file: + logger.info(f"Exporting label positions from {self.labels_file}") + self._export_label_positions() + + def _export_sia405_abwasser(self): + logger.info("Exporting TWW.organisation -> ABWASSER.organisation") + self._export_organisation() + self._check_for_stop() + + logger.info("Exporting TWW.channel -> ABWASSER.kanal") + self._export_channel() + self._check_for_stop() + + logger.info("Exporting TWW.manhole -> ABWASSER.normschacht") + self._export_manhole() + self._check_for_stop() + + logger.info("Exporting TWW.discharge_point -> ABWASSER.einleitstelle") + self._export_discharge_point() + self._check_for_stop() + + logger.info("Exporting TWW.special_structure -> ABWASSER.spezialbauwerk") + self._export_special_structure() + self._check_for_stop() + + logger.info("Exporting TWW.infiltration_installation -> ABWASSER.versickerungsanlage") + self._export_infiltration_installation() + self._check_for_stop() + + logger.info("Exporting TWW.pipe_profile -> ABWASSER.rohrprofil") + self._export_pipe_profile() + self._check_for_stop() + + logger.info("Exporting TWW.reach_point -> ABWASSER.haltungspunkt") + self._export_reach_point() + self._check_for_stop() + + logger.info("Exporting TWW.wastewater_node -> ABWASSER.abwasserknoten") + self._export_wastewater_node() + self._check_for_stop() + + logger.info("Exporting TWW.reach -> ABWASSER.haltung") + self._export_reach() + self._check_for_stop() + + logger.info("Exporting TWW.dryweather_downspout -> ABWASSER.trockenwetterfallrohr") + self._export_dryweather_downspout() + self._check_for_stop() + + logger.info("Exporting TWW.access_aid -> ABWASSER.einstiegshilfe") + self._export_access_aid() + self._check_for_stop() + + logger.info("Exporting TWW.dryweather_flume -> ABWASSER.trockenwetterrinne") + self._export_dryweather_flume() + self._check_for_stop() + + logger.info("Exporting TWW.cover -> ABWASSER.deckel") + self._export_cover() + self._check_for_stop() + + logger.info("Exporting TWW.benching -> ABWASSER.bankett") + self._export_benching() + self._check_for_stop() + + def _export_dss(self): + logger.info( + "Exporting TWW.waste_water_treatment_plant -> ABWASSER.abwasserreinigungsanlage" + ) + self._export_waste_water_treatment_plant() + self._check_for_stop() + + logger.info("Exporting TWW.wwtp_energy_use -> ABWASSER.araenergienutzung") + self._export_wwtp_energy_use() + self._check_for_stop() + + logger.info("Exporting TWW.waste_water_treatment -> ABWASSER.abwasserbehandlung") + self._export_waste_water_treatment() + self._check_for_stop() + + logger.info("Exporting TWW.sludge_treatment -> ABWASSER.schlammbehandlung") + self._export_sludge_treatment() + self._check_for_stop() + + logger.info("Exporting TWW.wwtp_structure -> ABWASSER.arabauwerk") + self._export_wwtp_structure() + self._check_for_stop() + + logger.info("Exporting TWW.control_center -> ABWASSER.steuerungszentrale") + self._export_control_center() + self._check_for_stop() + + def _export_vsa_kek(self): + logger.info("Exporting TWW.examination -> ABWASSER.untersuchung") + self._export_examination() + self._check_for_stop() + + logger.info("Exporting TWW.damage_manhole -> ABWASSER.normschachtschaden") + self._export_damage_manhole() + self._check_for_stop() + + logger.info("Exporting TWW.damage_channel -> ABWASSER.kanalschaden") + self._export_damage_channel() + self._check_for_stop() + + logger.info("Exporting TWW.data_media -> ABWASSER.datentraeger") + self._export_data_media() + self._check_for_stop() + + logger.info("Exporting TWW.file -> ABWASSER.datei") + self._export_file() + self._check_for_stop() + + def _export_organisation(self): + query = self.tww_session.query(self.model_classes_tww_od.organisation) + for row in query: + organisation = self.model_classes_interlis.organisation( + # FIELDS TO MAP TO ABWASSER.organisation + # --- sia405_baseclass --- + **self.sia_405_base_common(row, "organisation"), + # --- organisation --- + auid=row.uid, + bemerkung=self.truncate(self.emptystr_to_null(row.remark), 80), + bezeichnung=self.null_to_emptystr(row.identifier), + organisationstyp=self.get_vl(row.organisation_type__REL), + astatus=self.get_vl(row.status__REL), + ) + self.abwasser_session.add(organisation) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_channel(self): + query = self.tww_session.query(self.model_classes_tww_od.channel) + if self.filtered: + query = query.join(self.model_classes_tww_od.wastewater_networkelement).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + kanal = self.model_classes_interlis.kanal( + # FIELDS TO MAP TO ABWASSER.kanal + # --- abwasserbauwerk --- + **self.wastewater_structure_common(row, "kanal"), + # --- kanal --- + bettung_umhuellung=self.get_vl(row.bedding_encasement__REL), + funktionhierarchisch=self.get_vl(row.function_hierarchic__REL), + funktionhydraulisch=self.get_vl(row.function_hydraulic__REL), + nutzungsart_geplant=self.get_vl(row.usage_planned__REL), + nutzungsart_ist=self.get_vl(row.usage_current__REL), + rohrlaenge=row.pipe_length, + spuelintervall=row.jetting_interval, + verbindungsart=self.get_vl(row.connection_type__REL), + ) + self.abwasser_session.add(kanal) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_manhole(self): + query = self.tww_session.query(self.model_classes_tww_od.manhole) + if self.filtered: + query = query.join(self.model_classes_tww_od.wastewater_networkelement).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + normschacht = self.model_classes_interlis.normschacht( + # --- abwasserbauwerk --- + **self.wastewater_structure_common(row, "normschacht"), + # --- normschacht --- + dimension1=row.dimension1, + dimension2=row.dimension2, + funktion=self.get_vl(row.function__REL), + material=self.get_vl(row.material__REL), + oberflaechenzulauf=self.get_vl(row.surface_inflow__REL), + ) + self.abwasser_session.add(normschacht) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_discharge_point(self): + query = self.tww_session.query(self.model_classes_tww_od.discharge_point) + if self.filtered: + query = query.join(self.model_classes_tww_od.wastewater_networkelement).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + einleitstelle = self.model_classes_interlis.einleitstelle( + # --- abwasserbauwerk --- + **self.wastewater_structure_common(row, "einleitstelle"), + # --- einleitstelle --- + hochwasserkote=row.highwater_level, + relevanz=self.get_vl(row.relevance__REL), + terrainkote=row.terrain_level, + wasserspiegel_hydraulik=row.waterlevel_hydraulic, + ) + self.abwasser_session.add(einleitstelle) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_special_structure(self): + query = self.tww_session.query(self.model_classes_tww_od.special_structure) + if self.filtered: + query = query.join(self.model_classes_tww_od.wastewater_networkelement).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + logger.warning( + "TWW field special_structure.upper_elevation has no equivalent in the interlis model. It will be ignored." + ) + spezialbauwerk = self.model_classes_interlis.spezialbauwerk( + # FIELDS TO MAP TO ABWASSER.spezialbauwerk + # --- abwasserbauwerk --- + **self.wastewater_structure_common(row, "spezialbauwerk"), + # --- spezialbauwerk --- + # TODO : WARNING : upper_elevation is not mapped + bypass=self.get_vl(row.bypass__REL), + funktion=self.get_vl(row.function__REL), + notueberlauf=self.get_vl(row.emergency_overflow__REL), + regenbecken_anordnung=self.get_vl(row.stormwater_tank_arrangement__REL), + ) + self.abwasser_session.add(spezialbauwerk) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_infiltration_installation(self): + query = self.tww_session.query(self.model_classes_tww_od.infiltration_installation) + if self.filtered: + query = query.join(self.model_classes_tww_od.wastewater_networkelement).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + logger.warning( + "TWW field infiltration_installation.upper_elevation has no equivalent in the interlis model. It will be ignored." + ) + versickerungsanlage = self.model_classes_interlis.versickerungsanlage( + # FIELDS TO MAP TO ABWASSER.versickerungsanlage + # --- abwasserbauwerk --- + **self.wastewater_structure_common(row, "versickerungsanlage"), + # --- versickerungsanlage --- + # TODO : NOT MAPPED : upper_elevation + art=self.get_vl(row.kind__REL), + beschriftung=self.get_vl(row.labeling__REL), + dimension1=row.dimension1, + dimension2=row.dimension2, + gwdistanz=row.distance_to_aquifer, + maengel=self.get_vl(row.defects__REL), + notueberlauf=self.get_vl(row.emergency_overflow__REL), + saugwagen=self.get_vl(row.vehicle_access__REL), + schluckvermoegen=row.absorption_capacity, + versickerungswasser=self.get_vl(row.seepage_utilization__REL), + wasserdichtheit=self.get_vl(row.watertightness__REL), + wirksameflaeche=row.effective_area, + ) + self.abwasser_session.add(versickerungsanlage) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_pipe_profile(self): + query = self.tww_session.query(self.model_classes_tww_od.pipe_profile) + if self.filtered: + query = query.join(self.model_classes_tww_od.reach).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.pipe_profile + + # --- pipe_profile --- + # fk_dataowner, fk_provider, height_width_ratio, identifier, last_modification, obj_id, profile_type, remark + + # --- _bwrel_ --- + # profile_geometry__BWREL_fk_pipe_profile, reach__BWREL_fk_pipe_profile + + # --- _rel_ --- + # fk_dataowner__REL, fk_provider__REL, profile_type__REL + + rohrprofil = self.model_classes_interlis.rohrprofil( + # FIELDS TO MAP TO ABWASSER.rohrprofil + # --- vsa_baseclass --- + **self.vsa_base_common(row, "rohrprofil"), + # --- rohrprofil --- + bemerkung=self.truncate(self.emptystr_to_null(row.remark), 80), + bezeichnung=self.null_to_emptystr(row.identifier), + hoehenbreitenverhaeltnis=row.height_width_ratio, + profiltyp=self.get_vl(row.profile_type__REL), + ) + self.abwasser_session.add(rohrprofil) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_reach_point(self): + query = self.tww_session.query(self.model_classes_tww_od.reach_point) + if self.filtered: + query = query.join( + self.model_classes_tww_od.reach, + or_( + self.model_classes_tww_od.reach_point.obj_id + == self.model_classes_tww_od.reach.fk_reach_point_from, + self.model_classes_tww_od.reach_point.obj_id + == self.model_classes_tww_od.reach.fk_reach_point_to, + ), + ).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.reach_point + + # --- reach_point --- + # elevation_accuracy, fk_dataowner, fk_provider, fk_wastewater_networkelement, identifier, last_modification, level, obj_id, outlet_shape, position_of_connection, remark, situation_geometry + + # --- _bwrel_ --- + # examination__BWREL_fk_reach_point, reach__BWREL_fk_reach_point_from, reach__BWREL_fk_reach_point_to + + # --- _rel_ --- + # elevation_accuracy__REL, fk_dataowner__REL, fk_provider__REL, fk_wastewater_networkelement__REL, outlet_shape__REL + + haltungspunkt = self.model_classes_interlis.haltungspunkt( + # FIELDS TO MAP TO ABWASSER.haltungspunkt + # --- vsa_baseclass --- + **self.vsa_base_common(row, "haltungspunkt"), + # --- haltungspunkt --- + abwassernetzelementref=self.get_tid(row.fk_wastewater_networkelement__REL), + auslaufform=self.get_vl(row.outlet_shape__REL), + bemerkung=self.truncate(self.emptystr_to_null(row.remark), 80), + bezeichnung=self.null_to_emptystr(row.identifier), + hoehengenauigkeit=self.get_vl(row.elevation_accuracy__REL), + kote=row.level, + lage=ST_Force2D(row.situation3d_geometry), + lage_anschluss=row.position_of_connection, + ) + self.abwasser_session.add(haltungspunkt) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_wastewater_node(self): + query = self.tww_session.query(self.model_classes_tww_od.wastewater_node) + if self.filtered: + query = query.filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.wastewater_node + + # --- wastewater_networkelement --- + # fk_dataowner, fk_provider, fk_wastewater_structure, identifier, last_modification, remark + + # --- wastewater_node --- + + # --- _bwrel_ --- + # catchment_area__BWREL_fk_wastewater_networkelement_rw_current, catchment_area__BWREL_fk_wastewater_networkelement_rw_planned, catchment_area__BWREL_fk_wastewater_networkelement_ww_current, catchment_area__BWREL_fk_wastewater_networkelement_ww_planned, connection_object__BWREL_fk_wastewater_networkelement, hydraulic_char_data__BWREL_fk_wastewater_node, overflow__BWREL_fk_overflow_to, overflow__BWREL_fk_wastewater_node, reach_point__BWREL_fk_wastewater_networkelement, throttle_shut_off_unit__BWREL_fk_wastewater_node, wastewater_structure__BWREL_fk_main_wastewater_node + + # --- _rel_ --- + # fk_dataowner__REL, fk_hydr_geometry__REL, fk_provider__REL, fk_wastewater_structure__REL + + logger.warning( + "TWW field wastewater_node.fk_hydr_geometry has no equivalent in the interlis model. It will be ignored." + ) + abwasserknoten = self.model_classes_interlis.abwasserknoten( + # FIELDS TO MAP TO ABWASSER.abwasserknoten + # --- abwassernetzelement --- + **self.wastewater_networkelement_common(row, "abwasserknoten"), + # --- abwasserknoten --- + # TODO : WARNING : fk_hydr_geometry is not mapped + lage=ST_Force2D(row.situation3d_geometry), + rueckstaukote_ist=row.backflow_level_current, + sohlenkote=row.bottom_level, + ) + self.abwasser_session.add(abwasserknoten) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_reach(self): + query = self.tww_session.query(self.model_classes_tww_od.reach) + if self.filtered: + query = query.filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.reach + + # --- wastewater_networkelement --- + # fk_dataowner, fk_provider, fk_wastewater_structure, identifier, last_modification, remark + + # --- reach --- + # clear_height, coefficient_of_friction, elevation_determination, fk_pipe_profile, fk_reach_point_from, fk_reach_point_to, horizontal_positioning, inside_coating, length_effective, material, obj_id, progression3d_geometry, reliner_material, reliner_nominal_size, relining_construction, relining_kind, ring_stiffness, slope_building_plan, wall_roughness + + # --- _bwrel_ --- + # catchment_area__BWREL_fk_wastewater_networkelement_rw_current, catchment_area__BWREL_fk_wastewater_networkelement_rw_planned, catchment_area__BWREL_fk_wastewater_networkelement_ww_current, catchment_area__BWREL_fk_wastewater_networkelement_ww_planned, connection_object__BWREL_fk_wastewater_networkelement, reach_point__BWREL_fk_wastewater_networkelement, reach_text__BWREL_fk_reach, txt_text__BWREL_fk_reach + + # --- _rel_ --- + # elevation_determination__REL, fk_dataowner__REL, fk_pipe_profile__REL, fk_provider__REL, fk_reach_point_from__REL, fk_reach_point_to__REL, fk_wastewater_structure__REL, horizontal_positioning__REL, inside_coating__REL, material__REL, reliner_material__REL, relining_construction__REL, relining_kind__REL + + logger.warning( + "TWW field reach.elevation_determination has no equivalent in the interlis model. It will be ignored." + ) + haltung = self.model_classes_interlis.haltung( + # FIELDS TO MAP TO ABWASSER.haltung + # --- abwassernetzelement --- + **self.wastewater_networkelement_common(row, "haltung"), + # --- haltung --- + # NOT MAPPED : elevation_determination + innenschutz=self.get_vl(row.inside_coating__REL), + laengeeffektiv=row.length_effective, + lagebestimmung=self.get_vl(row.horizontal_positioning__REL), + lichte_hoehe=row.clear_height, + material=self.get_vl(row.material__REL), + nachhaltungspunktref=self.get_tid(row.fk_reach_point_to__REL), + plangefaelle=row.slope_building_plan, # TODO : check, does this need conversion ? + reibungsbeiwert=row.coefficient_of_friction, + reliner_art=self.get_vl(row.relining_kind__REL), + reliner_bautechnik=self.get_vl(row.relining_construction__REL), + reliner_material=self.get_vl(row.reliner_material__REL), + reliner_nennweite=row.reliner_nominal_size, + ringsteifigkeit=row.ring_stiffness, + rohrprofilref=self.get_tid(row.fk_pipe_profile__REL), + verlauf=ST_Force2D(row.progression3d_geometry), + vonhaltungspunktref=self.get_tid(row.fk_reach_point_from__REL), + wandrauhigkeit=row.wall_roughness, + ) + self.abwasser_session.add(haltung) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_dryweather_downspout(self): + query = self.tww_session.query(self.model_classes_tww_od.dryweather_downspout) + if self.filtered: + query = query.join( + self.model_classes_tww_od.wastewater_structure, + self.model_classes_tww_od.wastewater_networkelement, + ).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.dryweather_downspout + + # --- structure_part --- + # fk_dataowner, fk_provider, fk_wastewater_structure, identifier, last_modification, remark, renovation_demand + + # --- dryweather_downspout --- + # diameter, obj_id + + # --- _bwrel_ --- + # access_aid_kind__BWREL_obj_id, backflow_prevention__BWREL_obj_id, benching_kind__BWREL_obj_id, dryweather_flume_material__BWREL_obj_id, electric_equipment__BWREL_obj_id, electromechanical_equipment__BWREL_obj_id, solids_retention__BWREL_obj_id, tank_cleaning__BWREL_obj_id, tank_emptying__BWREL_obj_id + + # --- _rel_ --- + # fk_dataowner__REL, fk_provider__REL, fk_wastewater_structure__REL, renovation_demand__REL + + trockenwetterfallrohr = self.model_classes_interlis.trockenwetterfallrohr( + # FIELDS TO MAP TO ABWASSER.trockenwetterfallrohr + # --- bauwerksteil --- + **self.structure_part_common(row, "trockenwetterfallrohr"), + # --- trockenwetterfallrohr --- + durchmesser=row.diameter, + ) + self.abwasser_session.add(trockenwetterfallrohr) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_access_aid(self): + query = self.tww_session.query(self.model_classes_tww_od.access_aid) + if self.filtered: + query = query.join( + self.model_classes_tww_od.wastewater_structure, + self.model_classes_tww_od.wastewater_networkelement, + ).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.access_aid + + # --- structure_part --- + # fk_dataowner, fk_provider, fk_wastewater_structure, identifier, last_modification, remark, renovation_demand + + # --- access_aid --- + # kind, obj_id + + # --- _bwrel_ --- + # access_aid_kind__BWREL_obj_id, backflow_prevention__BWREL_obj_id, benching_kind__BWREL_obj_id, dryweather_flume_material__BWREL_obj_id, electric_equipment__BWREL_obj_id, electromechanical_equipment__BWREL_obj_id, solids_retention__BWREL_obj_id, tank_cleaning__BWREL_obj_id, tank_emptying__BWREL_obj_id + + # --- _rel_ --- + # fk_dataowner__REL, fk_provider__REL, fk_wastewater_structure__REL, kind__REL, renovation_demand__REL + + einstiegshilfe = self.model_classes_interlis.einstiegshilfe( + # FIELDS TO MAP TO ABWASSER.einstiegshilfe + # --- bauwerksteil --- + **self.structure_part_common(row, "einstiegshilfe"), + # --- einstiegshilfe --- + art=self.get_vl(row.kind__REL), + ) + self.abwasser_session.add(einstiegshilfe) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_dryweather_flume(self): + query = self.tww_session.query(self.model_classes_tww_od.dryweather_flume) + if self.filtered: + query = query.join( + self.model_classes_tww_od.wastewater_structure, + self.model_classes_tww_od.wastewater_networkelement, + ).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.dryweather_flume + + # --- structure_part --- + # fk_dataowner, fk_provider, fk_wastewater_structure, identifier, last_modification, remark, renovation_demand + + # --- dryweather_flume --- + # material, obj_id + + # --- _bwrel_ --- + # access_aid_kind__BWREL_obj_id, backflow_prevention__BWREL_obj_id, benching_kind__BWREL_obj_id, dryweather_flume_material__BWREL_obj_id, electric_equipment__BWREL_obj_id, electromechanical_equipment__BWREL_obj_id, solids_retention__BWREL_obj_id, tank_cleaning__BWREL_obj_id, tank_emptying__BWREL_obj_id + + # --- _rel_ --- + # fk_dataowner__REL, fk_provider__REL, fk_wastewater_structure__REL, material__REL, renovation_demand__REL + + trockenwetterrinne = self.model_classes_interlis.trockenwetterrinne( + # FIELDS TO MAP TO ABWASSER.trockenwetterrinne + # --- bauwerksteil --- + **self.structure_part_common(row, "trockenwetterrinne"), + # --- trockenwetterrinne --- + material=self.get_vl(row.material__REL), + ) + self.abwasser_session.add(trockenwetterrinne) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_cover(self): + query = self.tww_session.query(self.model_classes_tww_od.cover) + if self.filtered: + query = query.join( + self.model_classes_tww_od.wastewater_structure, + self.model_classes_tww_od.wastewater_networkelement, + ).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.cover + + # --- structure_part --- + # fk_dataowner, fk_provider, fk_wastewater_structure, identifier, last_modification, remark, renovation_demand + + # --- cover --- + # brand, cover_shape, diameter, fastening, level, material, obj_id, positional_accuracy, situation3d_geometry, sludge_bucket, venting + + # --- _bwrel_ --- + # access_aid_kind__BWREL_obj_id, backflow_prevention__BWREL_obj_id, benching_kind__BWREL_obj_id, dryweather_flume_material__BWREL_obj_id, electric_equipment__BWREL_obj_id, electromechanical_equipment__BWREL_obj_id, solids_retention__BWREL_obj_id, tank_cleaning__BWREL_obj_id, tank_emptying__BWREL_obj_id, wastewater_structure__BWREL_fk_main_cover + + # --- _rel_ --- + # cover_shape__REL, fastening__REL, fk_dataowner__REL, fk_provider__REL, fk_wastewater_structure__REL, material__REL, positional_accuracy__REL, renovation_demand__REL, sludge_bucket__REL, venting__REL + + deckel = self.model_classes_interlis.deckel( + # FIELDS TO MAP TO ABWASSER.deckel + # --- bauwerksteil --- + **self.structure_part_common(row, "deckel"), + # --- deckel --- + deckelform=self.get_vl(row.cover_shape__REL), + durchmesser=row.diameter, + entlueftung=self.get_vl(row.venting__REL), + fabrikat=row.brand, + kote=row.level, + lage=ST_Force2D(row.situation3d_geometry), + lagegenauigkeit=self.get_vl(row.positional_accuracy__REL), + material=self.get_vl(row.material__REL), + schlammeimer=self.get_vl(row.sludge_bucket__REL), + verschluss=self.get_vl(row.fastening__REL), + ) + self.abwasser_session.add(deckel) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_benching(self): + query = self.tww_session.query(self.model_classes_tww_od.benching) + if self.filtered: + query = query.join( + self.model_classes_tww_od.wastewater_structure, + self.model_classes_tww_od.wastewater_networkelement, + ).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.benching + + # --- structure_part --- + # fk_dataowner, fk_provider, fk_wastewater_structure, identifier, last_modification, remark, renovation_demand + + # --- benching --- + # kind, obj_id + + # --- _bwrel_ --- + # access_aid_kind__BWREL_obj_id, backflow_prevention__BWREL_obj_id, benching_kind__BWREL_obj_id, dryweather_flume_material__BWREL_obj_id, electric_equipment__BWREL_obj_id, electromechanical_equipment__BWREL_obj_id, solids_retention__BWREL_obj_id, tank_cleaning__BWREL_obj_id, tank_emptying__BWREL_obj_id + + # --- _rel_ --- + # fk_dataowner__REL, fk_provider__REL, fk_wastewater_structure__REL, kind__REL, renovation_demand__REL + + bankett = self.model_classes_interlis.bankett( + # FIELDS TO MAP TO ABWASSER.bankett + # --- bauwerksteil --- + **self.structure_part_common(row, "bankett"), + # --- bankett --- + art=self.get_vl(row.kind__REL), + ) + self.abwasser_session.add(bankett) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_waste_water_treatment_plant(self): + query = self.tww_session.query(self.model_classes_tww_od.waste_water_treatment_plant) + if self.filtered: + query = query.filter( + self.model_classes_tww_od.waste_water_treatment_plant.obj_id.in_(self.subset_ids) + ) + for row in query: + abwasserreinigungsanlage = self.model_classes_interlis.abwasserreinigungsanlage( + **self.vsa_base_common(row, "abwasserreinigungsanlage"), + # --- abwasserreinigungsanlage --- + perimeter=row.area_geometry, + bsb5=row.bod5, + csb=row.cod, + eliminationcsb=row.elimination_cod, + eliminationn=row.elimination_n, + eliminationnh4=row.elimination_nh4, + eliminationp=row.elimination_p, + bezeichnung=row.identifier, + art=row.kind, + nh4=row.nh4, + betreibertyp=self.get_vl(row.operator_type__REL), + einwohner_angeschlossen=row.population_connected, + einwohner_total=row.population_total, + bemerkung=row.remark, + lage=row.situation_geometry, + inbetriebnahme=row.start_year, + ara_nr=row.wwtp_number, + ) + self.abwasser_session.add(abwasserreinigungsanlage) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_wwtp_energy_use(self): + query = self.tww_session.query(self.model_classes_tww_od.wwtp_energy_use) + if self.filtered: + query = query.filter( + self.model_classes_tww_od.wwtp_energy_use.obj_id.in_(self.subset_ids) + ) + for row in query: + araenergienutzung = self.model_classes_interlis.araenergienutzung( + **self.vsa_base_common(row, "araenergienutzung"), + # --- araenergienutzung --- + gasmotor=row.gas_motor, + waermepumpe=row.heat_pump, + bezeichnung=row.identifier, + bemerkung=row.remark, + turbinierung=row.turbining, + abwasserreinigungsanlageref=self.get_tid(row.fk_waste_water_treatment_plant__REL), + ) + self.abwasser_session.add(araenergienutzung) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_waste_water_treatment(self): + query = self.tww_session.query(self.model_classes_tww_od.waste_water_treatment) + if self.filtered: + query = query.filter( + self.model_classes_tww_od.waste_water_treatment.obj_id.in_(self.subset_ids) + ) + for row in query: + abwasserbehandlung = self.model_classes_interlis.abwasserbehandlung( + **self.vsa_base_common(row, "abwasserbehandlung"), + # --- abwasserbehandlung --- + bezeichnung=row.identifier, + art=self.get_vl(row.kind__REL), + bemerkung=row.remark, + abwasserreinigungsanlageref=self.get_tid(row.fk_waste_water_treatment_plant__REL), + ) + self.abwasser_session.add(abwasserbehandlung) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_sludge_treatment(self): + query = self.tww_session.query(self.model_classes_tww_od.sludge_treatment) + if self.filtered: + query = query.filter( + self.model_classes_tww_od.sludge_treatment.obj_id.in_(self.subset_ids) + ) + for row in query: + schlammbehandlung = self.model_classes_interlis.schlammbehandlung( + **self.vsa_base_common(row, "schlammbehandlung"), + # --- schlammbehandlung --- + kompostierung=row.composting, + entwaesserung=row.dehydration, + faulschlammverbrennung=row.digested_sludge_combustion, + trocknung=row.drying, + frischschlammverbrennung=row.fresh_sludge_combustion, + hygienisierung=row.hygenisation, + bezeichnung=row.identifier, + ueberschusschlammvoreindickung=row.predensification_of_excess_sludge, + mischschlammvoreindickung=row.predensification_of_mixed_sludge, + primaerschlammvoreindickung=row.predensification_of_primary_sludge, + bemerkung=row.remark, + stabilisierung=self.get_vl(row.stabilisation__REL), + entwaessertklaerschlammstapelung=row.stacking_of_dehydrated_sludge, + fluessigklaerschlammstapelung=row.stacking_of_liquid_sludge, + abwasserreinigungsanlageref=self.get_tid(row.fk_waste_water_treatment_plant__REL), + ) + self.abwasser_session.add(schlammbehandlung) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_wwtp_structure(self): + query = self.tww_session.query(self.model_classes_tww_od.wwtp_structure) + if self.filtered: + query = query.join( + self.model_classes_tww_od.wastewater_networkelement, + ).filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + for row in query: + arabauwerk = self.model_classes_interlis.arabauwerk( + # --- bauwerksteil --- + **self.wastewater_structure_common(row, "arabauwerk"), + # --- arabauwerk --- + art=self.get_vl(row.kind__REL), + abwasserreinigungsanlageref=self.get_tid(row.fk_waste_water_treatment_plant__REL), + ) + self.abwasser_session.add(arabauwerk) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_control_center(self): + query = self.tww_session.query(self.model_classes_tww_od.control_center) + if self.filtered: + query = query.filter( + self.model_classes_tww_od.control_center.obj_id.in_(self.subset_ids) + ) + for row in query: + steuerungszentrale = self.model_classes_interlis.steuerungszentrale( + **self.vsa_base_common(row, "steuerungszentrale"), + # --- steuerungszentrale --- + bezeichnung=row.identifier, + lage=row.situation_geometry, + ) + self.abwasser_session.add(steuerungszentrale) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_examination(self): + query = self.tww_session.query(self.model_classes_tww_od.examination) + if self.filtered: + query = ( + query.join(self.model_classes_tww_od.re_maintenance_event_wastewater_structure) + .join(self.model_classes_tww_od.wastewater_structure) + .join(self.model_classes_tww_od.wastewater_networkelement) + .filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + ) + + for row in query: + # AVAILABLE FIELDS IN TWW.examination + + # --- maintenance_event --- + # --- examination --- + # equipment, fk_reach_point, from_point_identifier, inspected_length, obj_id, recording_type, to_point_identifier, vehicle, videonumber, weather + + # --- _bwrel_ --- + # damage__BWREL_fk_examination, re_maintenance_event_wastewater_structure__BWREL_fk_maintenance_event + + # --- _rel_ --- + # fk_dataowner__REL, fk_operating_company__REL, fk_provider__REL, fk_reach_point__REL, kind__REL, recording_type__REL, status__REL, weather__REL + logger.warning( + "TWW field maintenance_event.active_zone has no equivalent in the interlis model. It will be ignored." + ) + + untersuchung = self.model_classes_interlis.untersuchung( + # FIELDS TO MAP TO ABWASSER.untersuchung + # --- baseclass --- + # --- sia405_baseclass --- + **self.vsa_base_common(row, "untersuchung"), + # --- erhaltungsereignis --- + # abwasserbauwerkref=row.REPLACE_ME, # TODO : convert this to M2N relation through re_maintenance_event_wastewater_structure + art=self.get_vl(row.kind__REL), + astatus=self.get_vl(row.status__REL), + ausfuehrende_firmaref=self.get_tid(row.fk_operating_company__REL), + ausfuehrender=row.operator, + bemerkung=self.truncate(self.emptystr_to_null(row.remark), 80), + bezeichnung=self.null_to_emptystr(row.identifier), + datengrundlage=row.base_data, + dauer=row.duration, + detaildaten=row.data_details, + ergebnis=row.result, + grund=row.reason, + kosten=row.cost, + zeitpunkt=row.time_point, + # --- untersuchung --- + bispunktbezeichnung=row.to_point_identifier, + erfassungsart=self.get_vl(row.recording_type__REL), + fahrzeug=row.vehicle, + geraet=row.equipment, + haltungspunktref=self.get_tid(row.fk_reach_point__REL), + inspizierte_laenge=row.inspected_length, + videonummer=row.videonumber, + vonpunktbezeichnung=row.from_point_identifier, + witterung=self.get_vl(row.weather__REL), + ) + self.abwasser_session.add(untersuchung) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_damage_manhole(self): + query = self.tww_session.query(self.model_classes_tww_od.damage_manhole) + if self.filtered: + query = ( + query.join(self.model_classes_tww_od.examination) + .join(self.model_classes_tww_od.re_maintenance_event_wastewater_structure) + .join(self.model_classes_tww_od.wastewater_structure) + .join(self.model_classes_tww_od.wastewater_networkelement) + .filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.damage_manhole + + # --- damage --- + + # --- damage_manhole --- + # manhole_damage_code, manhole_shaft_area, obj_id + + # --- _bwrel_ --- + # damage_channel_channel_damage_code__BWREL_obj_id + + # --- _rel_ --- + # connection__REL, fk_dataowner__REL, fk_examination__REL, fk_provider__REL, manhole_damage_code__REL, manhole_shaft_area__REL, single_damage_class__REL + + normschachtschaden = self.model_classes_interlis.normschachtschaden( + # FIELDS TO MAP TO ABWASSER.normschachtschaden + # --- baseclass --- + # --- sia405_baseclass --- + **self.vsa_base_common(row, "normschachtschaden"), + # --- schaden --- + anmerkung=row.comments, + ansichtsparameter=row.view_parameters, + einzelschadenklasse=self.get_vl(row.single_damage_class__REL), + streckenschaden=row.damage_reach, + untersuchungref=self.get_tid(row.fk_examination__REL), + verbindung=self.get_vl(row.connection__REL), + videozaehlerstand=row.video_counter, + # --- normschachtschaden --- + distanz=row.distance, + quantifizierung1=row.quantification1, + quantifizierung2=row.quantification2, + schachtbereich=self.get_vl(row.manhole_shaft_area__REL), + schachtschadencode=self.get_vl(row.manhole_damage_code__REL), + schadenlageanfang=row.damage_begin, + schadenlageende=row.damage_end, + ) + self.abwasser_session.add(normschachtschaden) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_damage_channel(self): + query = self.tww_session.query(self.model_classes_tww_od.damage_channel) + if self.filtered: + query = ( + query.join(self.model_classes_tww_od.examination) + .join(self.model_classes_tww_od.re_maintenance_event_wastewater_structure) + .join(self.model_classes_tww_od.wastewater_structure) + .join(self.model_classes_tww_od.wastewater_networkelement) + .filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.damage_channel + + # --- damage --- + # comments, connection, damage_begin, damage_end, damage_reach, distance, fk_dataowner, fk_examination, fk_provider, last_modification, quantification1, quantification2, single_damage_class, video_counter, view_parameters + + # --- damage_channel --- + # , obj_id + + # --- _bwrel_ --- + # damage_channel_channel_damage_code__BWREL_obj_id + + # --- _rel_ --- + # channel_damage_code__REL, connection__REL, fk_dataowner__REL, fk_examination__REL, fk_provider__REL, single_damage_class__REL + + kanalschaden = self.model_classes_interlis.kanalschaden( + # FIELDS TO MAP TO ABWASSER.kanalschaden + # --- baseclass --- + # --- sia405_baseclass --- + **self.vsa_base_common(row, "kanalschaden"), + # --- schaden --- + anmerkung=row.comments, + ansichtsparameter=row.view_parameters, + einzelschadenklasse=self.get_vl(row.single_damage_class__REL), + streckenschaden=row.damage_reach, + untersuchungref=self.get_tid(row.fk_examination__REL), + verbindung=self.get_vl(row.connection__REL), + videozaehlerstand=row.video_counter, + # --- kanalschaden --- + distanz=row.distance, + kanalschadencode=self.get_vl(row.channel_damage_code__REL), + quantifizierung1=row.quantification1, + quantifizierung2=row.quantification2, + schadenlageanfang=row.damage_begin, + schadenlageende=row.damage_end, + ) + self.abwasser_session.add(kanalschaden) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_data_media(self): + query = self.tww_session.query(self.model_classes_tww_od.data_media) + for row in query: + # AVAILABLE FIELDS IN TWW.data_media + + # --- data_media --- + # fk_dataowner, fk_provider, identifier, kind, last_modification, location, obj_id, path, remark + + # --- _rel_ --- + # fk_dataowner__REL, fk_provider__REL, kind__REL + + datentraeger = self.model_classes_interlis.datentraeger( + # FIELDS TO MAP TO ABWASSER.datentraeger + # --- vsa_baseclass --- + **self.vsa_base_common(row, "datentraeger"), + # --- datentraeger --- + art=self.get_vl(row.kind__REL), + bemerkung=self.truncate(self.emptystr_to_null(row.remark), 80), + bezeichnung=self.null_to_emptystr(row.identifier), + pfad=row.path, + standort=row.location, + ) + self.abwasser_session.add(datentraeger) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def _export_file(self): + query = self.tww_session.query(self.model_classes_tww_od.file) + if self.filtered: + query = ( + query.outerjoin( + self.model_classes_tww_od.damage, + self.model_classes_tww_od.file.object + == self.model_classes_tww_od.damage.obj_id, + ) + .join( + self.model_classes_tww_od.examination, + or_( + self.model_classes_tww_od.file.object + == self.model_classes_tww_od.damage.obj_id, + self.model_classes_tww_od.file.object + == self.model_classes_tww_od.examination.obj_id, + ), + ) + .join(self.model_classes_tww_od.re_maintenance_event_wastewater_structure) + .join(self.model_classes_tww_od.wastewater_structure) + .join(self.model_classes_tww_od.wastewater_networkelement) + .filter( + self.model_classes_tww_od.wastewater_networkelement.obj_id.in_(self.subset_ids) + ) + ) + for row in query: + # AVAILABLE FIELDS IN TWW.file + + # --- file --- + # class, fk_data_media, fk_dataowner, fk_provider, identifier, kind, last_modification, obj_id, object, path_relative, remark + + # --- _rel_ --- + # class__REL, fk_dataowner__REL, fk_provider__REL, kind__REL + + datei = self.model_classes_interlis.datei( + # FIELDS TO MAP TO ABWASSER.datei + # --- vsa_baseclass --- + **self.vsa_base_common(row, "datei"), + # --- datei --- + art=self.get_vl(row.kind__REL) or "andere", + bemerkung=self.truncate(self.emptystr_to_null(row.remark), 80), + bezeichnung=self.null_to_emptystr(row.identifier), + datentraegerref=self.get_tid(row.fk_data_media__REL), + klasse=self.get_vl(row.class__REL), + objekt=self.null_to_emptystr(row.object), + relativpfad=row.path_relative, + ) + self.abwasser_session.add(datei) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def get_tid(self, relation): + """ + Makes a tid for a relation + """ + if relation is None: + return None + return self.tid_maker.tid_for_row(relation) + + def get_vl(self, relation): + """ + Gets a literal value from a value list relation + """ + if relation is None: + return None + return relation.value_de + + def null_to_emptystr(self, val): + """ + Converts nulls to blank strings and raises a warning + """ + if val is None: + logger.warning( + "A mandatory value was null. It will be cast to a blank string, and probably cause validation errors", + ) + val = "" + return val + + def emptystr_to_null(self, val): + """ + Converts blank strings to nulls and raises a warning + + This is needed as is seems ili2pg 4.4.6 crashes with emptystrings under certain circumstances (see https://github.com/TWW/tww2ili/issues/33) + """ + if val == "": + logger.warning( + "An empty string was converted to NULL, to workaround ili2pg issue. This should have no impact on output.", + ) + val = None + return val + + def truncate(self, val, max_length): + """ + Raises a warning if values gets truncated + """ + if val is None: + return None + if len(val) > max_length: + logger.warning(f"Value '{val}' exceeds expected length ({max_length})", stacklevel=2) + return val[0:max_length] + + def _modulo_angle(self, val): + """ + Returns an angle between 0 and 359.9 (for Orientierung in Base_d-20181005.ili) + """ + if val is None: + return None + val = val % 360.0 + if val > 359.9: + val = 0 + return val + + def base_common(self, row, type_name): + """ + Returns common attributes for base + """ + return { + "t_ili_tid": row.obj_id, + "t_type": type_name, + "t_id": self.get_tid(row), + } + + def sia_405_base_common(self, row, type_name): + return { + **self.base_common(row, type_name), + "letzte_aenderung": row.last_modification, + } + + def vsa_base_common(self, row, type_name): + """ + Returns common attributes for base + """ + datenherrref = self.get_tid(row.fk_dataowner__REL) + if not datenherrref: + raise InterlisExporterToIntermediateSchemaError( + f"Invalid dataowner reference for object '{row.obj_id}' of type '{type_name}'" + ) + + datenlieferantref = self.get_tid(row.fk_provider__REL) + if not datenlieferantref: + raise InterlisExporterToIntermediateSchemaError( + f"Invalid provider reference for object '{row.obj_id}' of type '{type_name}'" + ) + + return { + **self.sia_405_base_common(row, type_name), + "datenherrref": datenherrref, + "datenlieferantref": datenlieferantref, + } + + def wastewater_structure_common(self, row, type_name): + """ + Returns common attributes for wastewater_structure + """ + logger.warning( + "Mapping of wastewater_structure->abwasserbauwerk is not fully implemented." + ) + + eigentuemerref = self.get_tid(row.fk_owner__REL) + if not eigentuemerref: + raise InterlisExporterToIntermediateSchemaError( + f"Invalid owner reference for object '{row.obj_id}' of type '{type_name}'" + ) + + return { + **self.vsa_base_common(row, type_name), + "akten": row.records, + "astatus": self.get_vl(row.status__REL), + "baujahr": row.year_of_construction, + "baulicherzustand": self.get_vl(row.structure_condition__REL), + "baulos": row.contract_section, + "bemerkung": self.truncate(self.emptystr_to_null(row.remark), 80), + "betreiberref": self.get_tid(row.fk_operator__REL), + "bezeichnung": self.null_to_emptystr(row.identifier), + "bruttokosten": row.gross_costs, + "detailgeometrie": ST_Force2D(row.detail_geometry3d_geometry), + "eigentuemerref": eigentuemerref, + "ersatzjahr": row.year_of_replacement, + "finanzierung": self.get_vl(row.financing__REL), + "inspektionsintervall": row.inspection_interval, + "sanierungsbedarf": self.get_vl(row.renovation_necessity__REL), + "standortname": row.location_name, + "subventionen": row.subsidies, + "wbw_basisjahr": row.rv_base_year, + "wbw_bauart": self.get_vl(row.rv_construction_type__REL), + "wiederbeschaffungswert": row.replacement_value, + "zugaenglichkeit": self.get_vl(row.accessibility__REL), + } + + def wastewater_networkelement_common(self, row, type_name): + """ + Returns common attributes for network_element + """ + return { + **self.vsa_base_common(row, type_name), + "abwasserbauwerkref": self.get_tid(row.fk_wastewater_structure__REL), + "bemerkung": self.truncate(self.emptystr_to_null(row.remark), 80), + "bezeichnung": self.null_to_emptystr(row.identifier), + } + + def structure_part_common(self, row, type_name): + """ + Returns common attributes for structure_part + """ + return { + **self.vsa_base_common(row, type_name), + "abwasserbauwerkref": self.get_tid(row.fk_wastewater_structure__REL), + "bemerkung": self.truncate(self.emptystr_to_null(row.remark), 80), + "bezeichnung": self.null_to_emptystr(row.identifier), + "instandstellung": self.get_vl(row.renovation_demand__REL), + } + + def _textpos_common(self, row, t_type, geojson_crs_def): + """ + Returns common attributes for textpos + """ + t_id = self.tid_maker.next_tid() + return { + "t_id": t_id, + "t_type": t_type, + "t_ili_tid": t_id, + # --- TextPos --- + "textpos": ST_GeomFromGeoJSON( + json.dumps( + { + "type": "Point", + "coordinates": row["geometry"]["coordinates"], + "crs": geojson_crs_def, + } + ) + ), + "textori": self._modulo_angle(row["properties"]["LabelRotation"]), + "texthali": "Left", # can be Left/Center/Right + "textvali": "Bottom", # can be Top,Cap,Half,Base,Bottom + # --- SIA405_TextPos --- + "plantyp": row["properties"]["scale"], + "textinhalt": row["properties"]["LabelText"], + "bemerkung": None, + } + + def _export_label_positions(self): + logger.info(f"Exporting label positions from {self.labels_file}") + + # Get t_id by obj_name to create the reference on the labels below + tid_for_obj_id = { + "vw_tww_reach": {}, + "vw_tww_wastewater_structure": {}, + "catchment_area": {}, + } + for row in self.abwasser_session.query(self.model_classes_interlis.haltung): + tid_for_obj_id["vw_tww_reach"][row.t_ili_tid] = row.t_id + for row in self.abwasser_session.query(self.model_classes_interlis.abwasserbauwerk): + tid_for_obj_id["vw_tww_wastewater_structure"][row.t_ili_tid] = row.t_id + for row in self.abwasser_session.query(self.model_classes_interlis.einzugsgebiet): + tid_for_obj_id["catchment_area"][row.t_ili_tid] = row.t_id + + with open(self.labels_file) as labels_file_handle: + labels = json.load(labels_file_handle) + + geojson_crs_def = labels["crs"] + + for label in labels["features"]: + layer_name = label["properties"]["Layer"] + obj_id = label["properties"]["tww_obj_id"] + + print(f"label[properties]: {label['properties']}") + + if self.subset_ids and obj_id not in self.subset_ids: + logger.warning( + f"Label for {layer_name} `{obj_id}` exists, but that object is not part of the export" + ) + continue + + if not label["properties"]["LabelText"]: + logger.warning( + f"Label of object '{obj_id}' from layer '{layer_name}' is empty and will not be exported" + ) + continue + + t_id = tid_for_obj_id.get(layer_name, {}).get(obj_id, None) + if not t_id: + logger.warning( + f"Label for '{layer_name}' '{obj_id}' exists, but that object is not part of the export" + ) + continue + + if layer_name == "vw_tww_reach": + ili_label = self.model_classes_interlis.haltung_text( + **self._textpos_common(label, "haltung_text", geojson_crs_def), + haltungref=t_id, + ) + + elif layer_name == "vw_tww_wastewater_structure": + ili_label = self.model_classes_interlis.abwasserbauwerk_text( + **self._textpos_common(label, "abwasserbauwerk_text", geojson_crs_def), + abwasserbauwerkref=t_id, + ) + + elif layer_name == "catchment_area": + ili_label = self.model_classes_interlis.einzugsgebiet_text( + **self._textpos_common(label, "einzugsgebiet_text", geojson_crs_def), + einzugsgebietref=t_id, + ) + + else: + logger.warning( + f"Unknown layer `{layer_name}` for label with id '{obj_id}'. Label will be ignored", + ) + continue + + self.abwasser_session.add(ili_label) + print(".", end="") + logger.info("done") + self.abwasser_session.flush() + + def close_sessions(self): + self.tww_session.close() + self.abwasser_session.close() + + def _check_for_stop(self): + if self.callback_progress_done: + self.callback_progress_done() diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/interlis_importer_to_intermediate_schema.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/interlis_importer_to_intermediate_schema.py new file mode 100644 index 000000000..ff30debd2 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_model_mapping/interlis_importer_to_intermediate_schema.py @@ -0,0 +1,969 @@ +from geoalchemy2.functions import ST_Force3D +from sqlalchemy.orm import Session +from sqlalchemy.orm.attributes import flag_dirty +from sqlalchemy.sql import text + +from .. import config, utils +from ..utils.various import logger + + +class InterlisImporterToIntermediateSchema: + def __init__( + self, + model, + model_classes_interlis, + model_classes_tww_od, + model_classes_tww_vl, + callback_progress_done=None, + ): + self.model = model + self.callback_progress_done = callback_progress_done + + self.model_classes_interlis = model_classes_interlis + self.model_classes_tww_od = model_classes_tww_od + self.model_classes_tww_vl = model_classes_tww_vl + + self.session_interlis = None + self.session_tww = None + + def tww_import(self, skip_closing_tww_session=False): + try: + self._tww_import(skip_closing_tww_session) + except Exception as exception: + try: + self.session_tww.rollback() + self.session_tww.close() + self.session_interlis.close() + except Exception as cleanup_exception: + logger.warning(f"Could not close sessions cleanly: {cleanup_exception}") + raise exception + + def _tww_import(self, skip_closing_tww_session): + """ + Imports data from the ili2pg model into the TWW model. + + Args: + precommit_callback: optional callable that gets invoked with the sqlalchemy's session, + allowing for a GUI to filter objects before committing. It MUST either + commit or rollback and close the session. + """ + + pre_session = Session( + utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False + ) + + # We also drop symbology triggers as they badly affect performance. This must be done in a separate session as it + # would deadlock other sessions. + pre_session.execute(text("SELECT tww_sys.disable_symbology_triggers();")) + pre_session.commit() + pre_session.close() + + # We use two different sessions for reading and writing so it's easier to + # review imports and to keep the door open to getting data from another + # connection / database type. + self.session_interlis = Session( + utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False + ) + self.session_tww = Session( + utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False + ) + + # Allow to insert rows with cyclic dependencies at once + self.session_tww.execute(text("SET CONSTRAINTS ALL DEFERRED;")) + + self._import_sia405_abwasser() + + if self.model == config.MODEL_NAME_DSS: + self._import_dss() + + if self.model == config.MODEL_NAME_VSA_KEK: + self._import_vsa_kek() + + self.close_sessions(skip_closing_tww_session=skip_closing_tww_session) + + def _import_sia405_abwasser(self): + logger.info("Importing ABWASSER.organisation -> TWW.organisation") + self._import_organisation() + self._check_for_stop() + + logger.info("Importing ABWASSER.kanal -> TWW.channel") + self._import_kanal() + self._check_for_stop() + + logger.info("Importing ABWASSER.normschacht -> TWW.manhole") + self._import_normschacht() + self._check_for_stop() + + logger.info("Importing ABWASSER.einleitstelle -> TWW.discharge_point") + self._import_einleitstelle() + self._check_for_stop() + + logger.info("Importing ABWASSER.spezialbauwerk -> TWW.special_structure") + self._import_spezialbauwerk() + self._check_for_stop() + + logger.info("Importing ABWASSER.versickerungsanlage -> TWW.infiltration_installation") + self._import_versickerungsanlage() + self._check_for_stop() + + logger.info("Importing ABWASSER.rohrprofil -> TWW.pipe_profile") + self._import_rohrprofil() + self._check_for_stop() + + logger.info("Importing ABWASSER.abwasserknoten -> TWW.wastewater_node") + self._import_abwasserknoten() + self._check_for_stop() + + logger.info("Importing ABWASSER.haltung -> TWW.reach") + self._import_haltung() + self._check_for_stop() + + logger.info("Importing ABWASSER.haltungspunkt -> TWW.reach_point") + self._import_haltungspunkt() + self._check_for_stop() + + logger.info("Importing ABWASSER.trockenwetterfallrohr -> TWW.dryweather_downspout") + self._import_trockenwetterfallrohr() + self._check_for_stop() + + logger.info("Importing ABWASSER.einstiegshilfe -> TWW.access_aid") + self._import_einstiegshilfe() + self._check_for_stop() + + logger.info("Importing ABWASSER.trockenwetterrinne -> TWW.dryweather_flume") + self._import_trockenwetterrinne() + self._check_for_stop() + + logger.info("Importing ABWASSER.deckel -> TWW.cover") + self._import_deckel() + self._check_for_stop() + + logger.info("Importing ABWASSER.bankett -> TWW.benching") + self._import_bankett() + self._check_for_stop() + + def _import_dss(self): + logger.info( + "Importing ABWASSER.abwasserreinigungsanlage -> TWW.waste_water_treatment_plant" + ) + self._import_abwasserreinigungsanlage() + self._check_for_stop() + + logger.info("Importing ABWASSER.araenergienutzung -> TWW.wwtp_energy_use") + self._import_araenergienutzung() + self._check_for_stop() + + logger.info("Importing ABWASSER.abwasserbehandlung -> TWW.waste_water_treatment") + self._import_abwasserbehandlung() + self._check_for_stop() + + logger.info("Importing ABWASSER.schlammbehandlung -> TWW.sludge_treatment") + self._import_schlammbehandlung() + self._check_for_stop() + + logger.info("Importing ABWASSER.arabauwerk -> TWW.wwtp_structure") + self._import_arabauwerk() + self._check_for_stop() + + logger.info("Importing ABWASSER.steuerungszentrale -> TWW.control_center") + self._import_steuerungszentrale() + self._check_for_stop() + + def _import_vsa_kek(self): + logger.info("Importing ABWASSER.untersuchung -> TWW.examination") + self._import_untersuchung() + self._check_for_stop() + + logger.info("Importing ABWASSER.normschachtschaden -> TWW.damage_manhole") + self._import_normschachtschaden() + self._check_for_stop() + + logger.info("Importing ABWASSER.kanalschaden -> TWW.damage_channel") + self._import_kanalschaden() + self._check_for_stop() + + logger.info("Importing ABWASSER.datentraeger -> TWW.data_media") + self._import_datentraeger() + self._check_for_stop() + + logger.info("Importing ABWASSER.datei -> TWW.file") + self._import_datei() + self._check_for_stop() + + def close_sessions(self, skip_closing_tww_session=False): + # Calling the precommit callback if provided, allowing to filter before final import + if not skip_closing_tww_session: + self.session_tww.commit() + self.session_tww.close() + self.session_interlis.close() + + try: + post_session = Session( + utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False + ) + post_session.execute(text("SELECT tww_sys.enable_symbology_triggers();")) + post_session.commit() + post_session.close() + + except Exception as exception: + logger.error(f"Could not re-enable symbology triggers: '{exception}'") + + def get_vl_instance(self, vl_table, value_de): + """ + Gets a value list instance from the value_de name. Returns None and a warning if not found. + """ + # TODO : memoize (and get the whole table at once) to improve N+1 performance issue + # TODO : return "other" (or other applicable value) rather than None, or even throwing an exception, would probably be better + instance = self.session_tww.query(vl_table).filter(vl_table.value_de == value_de).first() + if instance is None: + logger.warning( + f'Could not find value `{value_de}` in value list "{vl_table.__table__.schema}.{vl_table.__name__}". Setting to None instead.' + ) + return None + return instance + + def get_vl_code(self, vl_table, value_de): + instance = self.get_vl_instance(vl_table, value_de) + if instance is None: + return None + return instance.code + + def get_pk(self, relation): + """ + Returns the primary key for a relation + """ + if relation is None: + return None + return relation.t_ili_tid + + def create_or_update(self, cls, **kwargs): + """ + Updates an existing instance (if obj_id is found) or creates an instance of the provided class + with given kwargs, and returns it. + """ + instance = None + + # We try to get the instance from the session/database + obj_id = kwargs.get("obj_id", None) + if obj_id: + instance = self.session_tww.query(cls).get(kwargs.get("obj_id", None)) + + if instance: + # We found it -> update + instance.__dict__.update(kwargs) + flag_dirty(instance) # we flag it as dirty so it stays in the session + else: + # We didn't find it -> create + instance = cls(**kwargs) + + return instance + + def base_common(self, row): + """ + Returns common attributes for base + """ + return { + "obj_id": row.t_ili_tid, + "fk_dataowner": row.datenherrref, + "fk_provider": row.datenlieferantref, + "last_modification": row.letzte_aenderung, + } + + def wastewater_structure_common(self, row): + """ + Returns common attributes for wastewater_structure + """ + return { + "accessibility": self.get_vl_code( + self.model_classes_tww_od.wastewater_structure_accessibility, row.zugaenglichkeit + ), + "contract_section": row.baulos, + "detail_geometry3d_geometry": ST_Force3D(row.detailgeometrie), + "financing": self.get_vl_code( + self.model_classes_tww_od.wastewater_structure_financing, row.finanzierung + ), + "fk_operator": row.betreiberref, + "fk_owner": row.eigentuemerref, + "gross_costs": row.bruttokosten, + "identifier": row.bezeichnung, + "inspection_interval": row.inspektionsintervall, + "location_name": row.standortname, + "records": row.akten, + "remark": row.bemerkung, + "renovation_necessity": self.get_vl_code( + self.model_classes_tww_od.wastewater_structure_renovation_necessity, + row.sanierungsbedarf, + ), + "replacement_value": row.wiederbeschaffungswert, + "rv_base_year": row.wbw_basisjahr, + "rv_construction_type": self.get_vl_code( + self.model_classes_tww_od.wastewater_structure_rv_construction_type, row.wbw_bauart + ), + "status": self.get_vl_code( + self.model_classes_tww_vl.wastewater_structure_status, row.astatus + ), + "structure_condition": self.get_vl_code( + self.model_classes_tww_od.wastewater_structure_structure_condition, + row.baulicherzustand, + ), + "subsidies": row.subventionen, + "year_of_construction": row.baujahr, + "year_of_replacement": row.ersatzjahr, + } + + def wastewater_networkelement_common(self, row): + """ + Returns common attributes for network_element + """ + return { + "fk_wastewater_structure": self.get_pk(row.abwasserbauwerkref__REL), + "identifier": row.bezeichnung, + "remark": row.bemerkung, + } + + def structure_part_common(self, row): + """ + Returns common attributes for structure_part + """ + return { + "fk_wastewater_structure": self.get_pk(row.abwasserbauwerkref__REL), + "identifier": row.bezeichnung, + "remark": row.bemerkung, + "renovation_demand": self.get_vl_code( + self.model_classes_tww_od.structure_part_renovation_demand, row.instandstellung + ), + } + + def _import_organisation(self): + for row in self.session_interlis.query(self.model_classes_interlis.organisation): + organisation = self.create_or_update( + self.model_classes_tww_od.organisation, + obj_id=row.t_ili_tid, + # --- organisation --- + identifier=row.bezeichnung, + remark=row.bemerkung, + uid=row.auid, + municipality_number=row.gemeindenummer, + organisation_type=self.get_vl_code( + self.model_classes_tww_vl.organisation_organisation_type, row.organisationstyp + ), + status=self.get_vl_code( + self.model_classes_tww_vl.organisation_status, row.astatus + ), + ) + + self.session_tww.add(organisation) + print(".", end="") + + def _import_kanal(self): + for row in self.session_interlis.query(self.model_classes_interlis.kanal): + channel = self.create_or_update( + self.model_classes_tww_od.channel, + **self.base_common(row), + # --- wastewater_structure --- + **self.wastewater_structure_common(row), + # --- channel --- + bedding_encasement=self.get_vl_code( + self.model_classes_tww_od.channel_bedding_encasement, row.bettung_umhuellung + ), + connection_type=self.get_vl_code( + self.model_classes_tww_od.channel_connection_type, row.verbindungsart + ), + function_hierarchic=self.get_vl_code( + self.model_classes_tww_od.channel_function_hierarchic, row.funktionhierarchisch + ), + function_hydraulic=self.get_vl_code( + self.model_classes_tww_od.channel_function_hydraulic, row.funktionhydraulisch + ), + jetting_interval=row.spuelintervall, + pipe_length=row.rohrlaenge, + usage_current=self.get_vl_code( + self.model_classes_tww_od.channel_usage_current, row.nutzungsart_ist + ), + usage_planned=self.get_vl_code( + self.model_classes_tww_od.channel_usage_planned, row.nutzungsart_geplant + ), + ) + self.session_tww.add(channel) + print(".", end="") + + def _import_normschacht(self): + for row in self.session_interlis.query(self.model_classes_interlis.normschacht): + manhole = self.create_or_update( + self.model_classes_tww_od.manhole, + **self.base_common(row), + # --- wastewater_structure --- + **self.wastewater_structure_common(row), + # --- manhole --- + # _orientation=row.REPLACE_ME, + dimension1=row.dimension1, + dimension2=row.dimension2, + function=self.get_vl_code( + self.model_classes_tww_vl.manhole_function, row.funktion + ), + material=self.get_vl_code( + self.model_classes_tww_vl.manhole_material, row.material + ), + surface_inflow=self.get_vl_code( + self.model_classes_tww_od.manhole_surface_inflow, row.oberflaechenzulauf + ), + ) + self.session_tww.add(manhole) + print(".", end="") + + def _import_einleitstelle(self): + for row in self.session_interlis.query(self.model_classes_interlis.einleitstelle): + discharge_point = self.create_or_update( + self.model_classes_tww_od.discharge_point, + **self.base_common(row), + # --- wastewater_structure --- + **self.wastewater_structure_common(row), + # --- discharge_point --- + # fk_sector_water_body=row.REPLACE_ME, # TODO : NOT MAPPED + highwater_level=row.hochwasserkote, + relevance=self.get_vl_code( + self.model_classes_tww_od.discharge_point_relevance, row.relevanz + ), + terrain_level=row.terrainkote, + # upper_elevation=row.REPLACE_ME, # TODO : NOT MAPPED + waterlevel_hydraulic=row.wasserspiegel_hydraulik, + ) + self.session_tww.add(discharge_point) + print(".", end="") + + def _import_spezialbauwerk(self): + for row in self.session_interlis.query(self.model_classes_interlis.spezialbauwerk): + special_structure = self.create_or_update( + self.model_classes_tww_od.special_structure, + **self.base_common(row), + # --- wastewater_structure --- + **self.wastewater_structure_common(row), + # --- special_structure --- + bypass=self.get_vl_code( + self.model_classes_tww_vl.special_structure_bypass, row.bypass + ), + emergency_overflow=self.get_vl_code( + self.model_classes_tww_vl.special_structure_emergency_overflow, + row.notueberlauf, + ), + function=self.get_vl_code( + self.model_classes_tww_od.special_structure_function, row.funktion + ), + stormwater_tank_arrangement=self.get_vl_code( + self.model_classes_tww_od.special_structure_stormwater_tank_arrangement, + row.regenbecken_anordnung, + ), + # upper_elevation=row.REPLACE_ME, # TODO : NOT MAPPED + ) + self.session_tww.add(special_structure) + print(".", end="") + + def _import_versickerungsanlage(self): + for row in self.session_interlis.query(self.model_classes_interlis.versickerungsanlage): + infiltration_installation = self.create_or_update( + self.model_classes_tww_od.infiltration_installation, + **self.base_common(row), + # --- wastewater_structure --- + **self.wastewater_structure_common(row), + # --- infiltration_installation --- + absorption_capacity=row.schluckvermoegen, + defects=self.get_vl_code( + self.model_classes_tww_od.infiltration_installation_defects, row.maengel + ), + dimension1=row.dimension1, + dimension2=row.dimension2, + distance_to_aquifer=row.gwdistanz, + effective_area=row.wirksameflaeche, + emergency_overflow=self.get_vl_code( + self.model_classes_tww_od.infiltration_installation_emergency_overflow, + row.notueberlauf, + ), + # fk_aquifier=row.REPLACE_ME, # TODO : NOT MAPPED + kind=self.get_vl_code( + self.model_classes_tww_vl.infiltration_installation_kind, row.art + ), + labeling=self.get_vl_code( + self.model_classes_tww_od.infiltration_installation_labeling, row.beschriftung + ), + seepage_utilization=self.get_vl_code( + self.model_classes_tww_od.infiltration_installation_seepage_utilization, + row.versickerungswasser, + ), + # upper_elevation=row.REPLACE_ME, # TODO : NOT MAPPED + vehicle_access=self.get_vl_code( + self.model_classes_tww_od.infiltration_installation_vehicle_access, + row.saugwagen, + ), + watertightness=self.get_vl_code( + self.model_classes_tww_od.infiltration_installation_watertightness, + row.wasserdichtheit, + ), + ) + self.session_tww.add(infiltration_installation) + print(".", end="") + + def _import_abwasserreinigungsanlage(self): + for row in self.session_interlis.query( + self.model_classes_interlis.abwasserreinigungsanlage + ): + waste_water_treatment_plant = self.create_or_update( + self.model_classes_tww_od.waste_water_treatment_plant, + **self.base_common(row), + # --- waste_water_treatment_plant --- + area_geometry=row.perimeter, + bod5=row.bsb5, + cod=row.csb, + elimination_cod=row.eliminationcsb, + elimination_n=row.eliminationn, + elimination_nh4=row.eliminationnh4, + elimination_p=row.eliminationp, + identifier=row.bezeichnung, + kind=row.art, + nh4=row.nh4, + operator_type=self.get_vl_code( + self.model_classes_tww_vl.waste_water_treatment_plant_operator_type, + row.betreibertyp, + ), + population_connected=row.einwohner_angeschlossen, + population_total=row.einwohner_total, + remark=row.bemerkung, + situation_geometry=row.lage, + start_year=row.inbetriebnahme, + wwtp_number=row.ara_nr, + ) + self.session_tww.add(waste_water_treatment_plant) + print(".", end="") + + def _import_araenergienutzung(self): + for row in self.session_interlis.query(self.model_classes_interlis.araenergienutzung): + wwtp_energy_use = self.create_or_update( + self.model_classes_tww_od.wwtp_energy_use, + **self.base_common(row), + # --- wwtp_energy_use --- + gas_motor=row.gasmotor, + heat_pump=row.waermepumpe, + identifier=row.bezeichnung, + remark=row.bemerkung, + turbining=row.turbinierung, + fk_waste_water_treatment_plant=self.get_pk(row.abwasserreinigungsanlageref__REL), + ) + self.session_tww.add(wwtp_energy_use) + print(".", end="") + + def _import_abwasserbehandlung(self): + for row in self.session_interlis.query(self.model_classes_interlis.abwasserbehandlung): + waste_water_treatment = self.create_or_update( + self.model_classes_tww_od.waste_water_treatment, + **self.base_common(row), + # --- waste_water_treatment --- + identifier=row.bezeichnung, + kind=self.get_vl_code( + self.model_classes_tww_vl.waste_water_treatment_kind, row.art + ), + remark=row.bemerkung, + fk_waste_water_treatment_plant=self.get_pk(row.abwasserreinigungsanlageref__REL), + ) + self.session_tww.add(waste_water_treatment) + print(".", end="") + + def _import_schlammbehandlung(self): + for row in self.session_interlis.query(self.model_classes_interlis.schlammbehandlung): + sludge_treatment = self.create_or_update( + self.model_classes_tww_od.sludge_treatment, + **self.base_common(row), + # --- sludge_treatment --- + composting=row.kompostierung, + dehydration=row.entwaesserung, + digested_sludge_combustion=row.faulschlammverbrennung, + drying=row.trocknung, + fresh_sludge_combustion=row.frischschlammverbrennung, + hygenisation=row.hygienisierung, + identifier=row.bezeichnung, + predensification_of_excess_sludge=row.ueberschusschlammvoreindickung, + predensification_of_mixed_sludge=row.mischschlammvoreindickung, + predensification_of_primary_sludge=row.primaerschlammvoreindickung, + remark=row.bemerkung, + stabilisation=self.get_vl_code( + self.model_classes_tww_vl.sludge_treatment_stabilisation, row.stabilisierung + ), + stacking_of_dehydrated_sludge=row.entwaessertklaerschlammstapelung, + stacking_of_liquid_sludge=row.fluessigklaerschlammstapelung, + fk_waste_water_treatment_plant=self.get_pk(row.abwasserreinigungsanlageref__REL), + ) + self.session_tww.add(sludge_treatment) + print(".", end="") + + def _import_arabauwerk(self): + for row in self.session_interlis.query(self.model_classes_interlis.arabauwerk): + wwtp_structure = self.create_or_update( + self.model_classes_tww_od.wwtp_structure, + **self.base_common(row), + # --- wastewater_structure --- + **self.wastewater_structure_common(row), + # --- wwtp_structure --- + kind=self.get_vl_code(self.model_classes_tww_vl.wwtp_structure_kind, row.art), + fk_waste_water_treatment_plant=self.get_pk(row.abwasserreinigungsanlageref__REL), + ) + self.session_tww.add(wwtp_structure) + print(".", end="") + + def _import_steuerungszentrale(self): + for row in self.session_interlis.query(self.model_classes_interlis.steuerungszentrale): + control_center = self.create_or_update( + self.model_classes_tww_od.control_center, + **self.base_common(row), + # --- control_center --- + identifier=row.bezeichnung, + situation_geometry=row.lage, + ) + self.session_tww.add(control_center) + print(".", end="") + + def _import_rohrprofil(self): + for row in self.session_interlis.query(self.model_classes_interlis.rohrprofil): + pipe_profile = self.create_or_update( + self.model_classes_tww_od.pipe_profile, + **self.base_common(row), + # --- pipe_profile --- + height_width_ratio=row.hoehenbreitenverhaeltnis, + identifier=row.bezeichnung, + profile_type=self.get_vl_code( + self.model_classes_tww_od.pipe_profile_profile_type, row.profiltyp + ), + remark=row.bemerkung, + ) + self.session_tww.add(pipe_profile) + print(".", end="") + + def _import_haltungspunkt(self): + for row in self.session_interlis.query(self.model_classes_interlis.haltungspunkt): + reach_point = self.create_or_update( + self.model_classes_tww_od.reach_point, + **self.base_common(row), + # --- reach_point --- + elevation_accuracy=self.get_vl_code( + self.model_classes_tww_od.reach_point_elevation_accuracy, row.hoehengenauigkeit + ), + fk_wastewater_networkelement=self.get_pk(row.abwassernetzelementref__REL), + identifier=row.bezeichnung, + level=row.kote, + outlet_shape=self.get_vl_code( + self.model_classes_tww_od.reach_point_outlet_shape, row.hoehengenauigkeit + ), + position_of_connection=row.lage_anschluss, + remark=row.bemerkung, + situation3d_geometry=ST_Force3D(row.lage), + ) + self.session_tww.add(reach_point) + print(".", end="") + + def _import_abwasserknoten(self): + for row in self.session_interlis.query(self.model_classes_interlis.abwasserknoten): + wastewater_node = self.create_or_update( + self.model_classes_tww_od.wastewater_node, + **self.base_common(row), + # --- wastewater_networkelement --- + **self.wastewater_networkelement_common(row), + # --- wastewater_node --- + # fk_hydr_geometry=row.REPLACE_ME, # TODO : NOT MAPPED + backflow_level_current=row.rueckstaukote_ist, + bottom_level=row.sohlenkote, + situation3d_geometry=ST_Force3D(row.lage), + ) + self.session_tww.add(wastewater_node) + print(".", end="") + + def _import_haltung(self): + for row in self.session_interlis.query(self.model_classes_interlis.haltung): + reach = self.create_or_update( + self.model_classes_tww_od.reach, + **self.base_common(row), + # --- wastewater_networkelement --- + **self.wastewater_networkelement_common(row), + # --- reach --- + clear_height=row.lichte_hoehe, + coefficient_of_friction=row.reibungsbeiwert, + # elevation_determination=self.get_vl_code(TWW.reach_elevation_determination, row.REPLACE_ME), # TODO : NOT MAPPED + fk_pipe_profile=self.get_pk(row.rohrprofilref__REL), + fk_reach_point_from=self.get_pk(row.vonhaltungspunktref__REL), + fk_reach_point_to=self.get_pk(row.nachhaltungspunktref__REL), + horizontal_positioning=self.get_vl_code( + self.model_classes_tww_od.reach_horizontal_positioning, row.lagebestimmung + ), + inside_coating=self.get_vl_code( + self.model_classes_tww_od.reach_inside_coating, row.innenschutz + ), + length_effective=row.laengeeffektiv, + material=self.get_vl_code(self.model_classes_tww_vl.reach_material, row.material), + progression3d_geometry=ST_Force3D(row.verlauf), + reliner_material=self.get_vl_code( + self.model_classes_tww_od.reach_reliner_material, row.reliner_material + ), + reliner_nominal_size=row.reliner_nennweite, + relining_construction=self.get_vl_code( + self.model_classes_tww_od.reach_relining_construction, row.reliner_bautechnik + ), + relining_kind=self.get_vl_code( + self.model_classes_tww_od.reach_relining_kind, row.reliner_art + ), + ring_stiffness=row.ringsteifigkeit, + slope_building_plan=row.plangefaelle, # TODO : check, does this need conversion ? + wall_roughness=row.wandrauhigkeit, + ) + self.session_tww.add(reach) + print(".", end="") + + def _import_trockenwetterfallrohr(self): + for row in self.session_interlis.query(self.model_classes_interlis.trockenwetterfallrohr): + dryweather_downspout = self.create_or_update( + self.model_classes_tww_od.dryweather_downspout, + **self.base_common(row), + # --- structure_part --- + **self.structure_part_common(row), + # --- dryweather_downspout --- + diameter=row.durchmesser, + ) + self.session_tww.add(dryweather_downspout) + print(".", end="") + + def _import_einstiegshilfe(self): + for row in self.session_interlis.query(self.model_classes_interlis.einstiegshilfe): + access_aid = self.create_or_update( + self.model_classes_tww_od.access_aid, + **self.base_common(row), + # --- structure_part --- + **self.structure_part_common(row), + # --- access_aid --- + kind=self.get_vl_code(self.model_classes_tww_vl.access_aid_kind, row.art), + ) + self.session_tww.add(access_aid) + print(".", end="") + + def _import_trockenwetterrinne(self): + for row in self.session_interlis.query(self.model_classes_interlis.trockenwetterrinne): + dryweather_flume = self.create_or_update( + self.model_classes_tww_od.dryweather_flume, + **self.base_common(row), + # --- structure_part --- + **self.structure_part_common(row), + # --- dryweather_flume --- + material=self.get_vl_code( + self.model_classes_tww_od.dryweather_flume_material, row.material + ), + ) + self.session_tww.add(dryweather_flume) + print(".", end="") + + def _import_deckel(self): + for row in self.session_interlis.query(self.model_classes_interlis.deckel): + cover = self.create_or_update( + self.model_classes_tww_od.cover, + **self.base_common(row), + # --- structure_part --- + **self.structure_part_common(row), + # --- cover --- + brand=row.fabrikat, + cover_shape=self.get_vl_code( + self.model_classes_tww_vl.cover_cover_shape, row.deckelform + ), + diameter=row.durchmesser, + fastening=self.get_vl_code( + self.model_classes_tww_vl.cover_fastening, row.verschluss + ), + level=row.kote, + material=self.get_vl_code(self.model_classes_tww_vl.cover_material, row.material), + positional_accuracy=self.get_vl_code( + self.model_classes_tww_od.cover_positional_accuracy, row.lagegenauigkeit + ), + situation3d_geometry=ST_Force3D(row.lage), + sludge_bucket=self.get_vl_code( + self.model_classes_tww_od.cover_sludge_bucket, row.schlammeimer + ), + venting=self.get_vl_code(self.model_classes_tww_vl.cover_venting, row.entlueftung), + ) + self.session_tww.add(cover) + print(".", end="") + + def _import_bankett(self): + for row in self.session_interlis.query(self.model_classes_interlis.bankett): + benching = self.create_or_update( + self.model_classes_tww_od.benching, + **self.base_common(row), + # --- structure_part --- + **self.structure_part_common(row), + # --- benching --- + kind=self.get_vl_code(self.model_classes_tww_vl.benching_kind, row.art), + ) + self.session_tww.add(benching) + print(".", end="") + + def _import_untersuchung(self): + for row in self.session_interlis.query(self.model_classes_interlis.untersuchung): + logger.warning( + "TWW examination.active_zone has no equivalent in the interlis model. This field will be null." + ) + examination = self.create_or_update( + self.model_classes_tww_od.examination, + **self.base_common(row), + # --- maintenance_event --- + # active_zone=row.REPLACE_ME, # TODO : found no matching field for this in interlis, confirm this is ok + base_data=row.datengrundlage, + cost=row.kosten, + data_details=row.detaildaten, + duration=row.dauer, + fk_operating_company=row.ausfuehrende_firmaref + if row.ausfuehrende_firmaref + else None, + identifier=row.bezeichnung, + operator=row.ausfuehrender, + reason=row.grund, + remark=row.bemerkung, + result=row.ergebnis, + status=self.get_vl_code( + self.model_classes_tww_vl.maintenance_event_status, row.astatus + ), + time_point=row.zeitpunkt, + # --- examination --- + equipment=row.geraet, + fk_reach_point=row.haltungspunktref if row.haltungspunktref else None, + from_point_identifier=row.vonpunktbezeichnung, + inspected_length=row.inspizierte_laenge, + recording_type=self.get_vl_code( + self.model_classes_tww_od.examination_recording_type, row.erfassungsart + ), + to_point_identifier=row.bispunktbezeichnung, + vehicle=row.fahrzeug, + videonumber=row.videonummer, + weather=self.get_vl_code( + self.model_classes_tww_vl.examination_weather, row.witterung + ), + ) + self.session_tww.add(examination) + + # In TWW, relation between maintenance_event and wastewater_structure is done with + # an association table instead of a foreign key on maintenance_event. + # NOTE : this may change in future versions of VSA_KEK + if row.abwasserbauwerkref: + # TODO : for now, this will not work unless the related wastewaterstructures are part of the import, + # as ili2pg imports dangling references as NULL. + # The day ili2pg works, we probably need to double-check whether the referenced wastewater structure exists prior + # to creating this association. + # Soft matching based on from/to_point_identifier will be done in the GUI data checking process. + exam_to_wastewater_structure = self.create_or_update( + self.model_classes_tww_od.re_maintenance_event_wastewater_structure, + fk_wastewater_structure=row.abwasserbauwerkref, + fk_maintenance_event=row.t_ili_tid, + ) + self.session_tww.add(exam_to_wastewater_structure) + + print(".", end="") + + def _import_normschachtschaden(self): + for row in self.session_interlis.query(self.model_classes_interlis.normschachtschaden): + damage_manhole = self.create_or_update( + self.model_classes_tww_od.damage_manhole, + **self.base_common(row), + # --- damage --- + comments=row.anmerkung, + connection=self.get_vl_code( + self.model_classes_tww_vl.damage_connection, row.verbindung + ), + manhole_damage_begin=row.schadenlageanfang, + manhole_damage_end=row.schadenlageende, + line_damage=row.streckenschaden, + manhole_channel_distance=row.distanz, + fk_examination=row.untersuchungref__REL.t_ili_tid + if row.untersuchungref__REL + else None, + manhole_quantification1=row.quantifizierung1, + manhole_quantification2=row.quantifizierung2, + single_damage_class=self.get_vl_code( + self.model_classes_tww_od.damage_single_damage_class, row.einzelschadenklasse + ), + video_counter=row.videozaehlerstand, + view_parameters=row.ansichtsparameter, + # --- damage_manhole --- + manhole_damage_code=self.get_vl_code( + self.model_classes_tww_od.damage_manhole_manhole_damage_code, + row.schachtschadencode, + ), + manhole_shaft_area=self.get_vl_code( + self.model_classes_tww_od.damage_manhole_manhole_shaft_area, row.schachtbereich + ), + ) + self.session_tww.add(damage_manhole) + print(".", end="") + + def _import_kanalschaden(self): + for row in self.session_interlis.query(self.model_classes_interlis.kanalschaden): + # Note : in TWW, some attributes are on the base damage class, + # while they are on the normschachtschaden/kanalschaden subclasses + # in the ili2pg mode. + # Concerned attributes : distanz, quantifizierung1, quantifizierung2, schadenlageanfang, schadenlageende + damage_channel = self.create_or_update( + self.model_classes_tww_od.damage_channel, + **self.base_common(row), + # --- damage --- + comments=row.anmerkung, + connection=self.get_vl_code( + self.model_classes_tww_vl.damage_connection, row.verbindung + ), + channel_damage_begin=row.schadenlageanfang, + channel_damage_end=row.schadenlageende, + line_damage=row.streckenschaden, + channel_distance=row.distanz, + fk_examination=row.untersuchungref__REL.t_ili_tid + if row.untersuchungref__REL + else None, + channel_quantification1=row.quantifizierung1, + channel_quantification2=row.quantifizierung2, + single_damage_class=self.get_vl_code( + self.model_classes_tww_od.damage_single_damage_class, row.einzelschadenklasse + ), + video_counter=row.videozaehlerstand, + view_parameters=row.ansichtsparameter, + # --- damage_channel --- + channel_damage_code=self.get_vl_code( + self.model_classes_tww_od.damage_channel_channel_damage_code, + row.kanalschadencode, + ), + ) + self.session_tww.add(damage_channel) + print(".", end="") + + def _import_datentraeger(self): + for row in self.session_interlis.query(self.model_classes_interlis.datentraeger): + data_media = self.create_or_update( + self.model_classes_tww_od.data_media, + **self.base_common(row), + # --- data_media --- + identifier=row.bezeichnung, + kind=self.get_vl_code(self.model_classes_tww_vl.data_media_kind, row.art), + location=row.standort, + path=row.pfad, + remark=row.bemerkung, + ) + self.session_tww.add(data_media) + print(".", end="") + + def _import_datei(self): + for row in self.session_interlis.query(self.model_classes_interlis.datei): + file = self.create_or_update( + self.model_classes_tww_od.file, + **self.base_common(row), + # --- file --- + fk_data_media=row.datentraegerref__REL.t_ili_tid, + identifier=row.bezeichnung, + kind=self.get_vl_code(self.model_classes_tww_vl.file_kind, row.art), + object=row.objekt, + path_relative=row.relativpfad, + remark=row.bemerkung, + ) + # file.class = self.get_vl_code(self.model_classes_tww_vl.file_class, row.klasse) TODO + + self.session_tww.add(file) + print(".", end="") + + def _check_for_stop(self): + if self.callback_progress_done: + self.callback_progress_done() diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_base.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_base.py new file mode 100644 index 000000000..ad05e33b8 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_base.py @@ -0,0 +1,20 @@ +from sqlalchemy.ext.automap import automap_base + +from ..utils import tww_sqlalchemy + + +class ModelBase: + """ + Base class for datamodels + All tables will be loaded from the respective schemas (pg2ili, tww_od, tww_vl) as a SqlAlchemy ORM class. + Only table specific relationships (e.g. inheritance) need to be manually + defined here. Other attributes will be loaded automatically. + """ + + def __init__(self, schema): + self.Base = automap_base() + self.schema = schema + + def classes(self): + tww_sqlalchemy.prepare_automap_base(self.Base, self.schema) + return self.Base.classes diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_dss.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_dss.py new file mode 100644 index 000000000..bb7211685 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_dss.py @@ -0,0 +1,43 @@ +from .. import config +from .model_interlis_sia405_abwasser import ModelInterlisSia405Abwasser + + +class ModelInterlisDss(ModelInterlisSia405Abwasser): + def __init__(self): + super().__init__() + + class abwasserreinigungsanlage(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "abwasserreinigungsanlage" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisDss.abwasserreinigungsanlage = abwasserreinigungsanlage + + class araenergienutzung(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "araenergienutzung" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisDss.araenergienutzung = araenergienutzung + + class abwasserbehandlung(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "abwasserbehandlung" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisDss.abwasserbehandlung = abwasserbehandlung + + class schlammbehandlung(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "schlammbehandlung" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisDss.schlammbehandlung = schlammbehandlung + + class arabauwerk(ModelInterlisSia405Abwasser.abwasserbauwerk): + __tablename__ = "arabauwerk" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisDss.arabauwerk = arabauwerk + + class steuerungszentrale(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "steuerungszentrale" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisDss.steuerungszentrale = steuerungszentrale diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_sia405_abwasser.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_sia405_abwasser.py new file mode 100644 index 000000000..b0217d11f --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_sia405_abwasser.py @@ -0,0 +1,159 @@ +from .. import config +from .model_base import ModelBase + + +class ModelInterlisSia405Abwasser(ModelBase): + def __init__(self): + super().__init__(config.ABWASSER_SCHEMA) + + class baseclass(self.Base): + __tablename__ = "baseclass" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.baseclass = baseclass + + class sia405_baseclass(baseclass): + __tablename__ = "sia405_baseclass" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.sia405_baseclass = sia405_baseclass + + class vsa_baseclass(sia405_baseclass): + __tablename__ = "vsa_baseclass" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.vsa_baseclass = vsa_baseclass + + class organisation(sia405_baseclass): + __tablename__ = "organisation" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.organisation = organisation + + class abwasserbauwerk(vsa_baseclass): + __tablename__ = "abwasserbauwerk" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.abwasserbauwerk = abwasserbauwerk + + class kanal(abwasserbauwerk): + __tablename__ = "kanal" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.kanal = kanal + + class normschacht(abwasserbauwerk): + __tablename__ = "normschacht" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.normschacht = normschacht + + class einleitstelle(abwasserbauwerk): + __tablename__ = "einleitstelle" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.einleitstelle = einleitstelle + + class spezialbauwerk(abwasserbauwerk): + __tablename__ = "spezialbauwerk" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.spezialbauwerk = spezialbauwerk + + class versickerungsanlage(abwasserbauwerk): + __tablename__ = "versickerungsanlage" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.versickerungsanlage = versickerungsanlage + + class rohrprofil(vsa_baseclass): + __tablename__ = "rohrprofil" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.rohrprofil = rohrprofil + + class abwassernetzelement(vsa_baseclass): + __tablename__ = "abwassernetzelement" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.abwassernetzelement = abwassernetzelement + + class haltungspunkt(vsa_baseclass): + __tablename__ = "haltungspunkt" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.haltungspunkt = haltungspunkt + + class abwasserknoten(abwassernetzelement): + __tablename__ = "abwasserknoten" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.abwasserknoten = abwasserknoten + + class haltung(abwassernetzelement): + __tablename__ = "haltung" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.haltung = haltung + + class bauwerksteil(vsa_baseclass): + __tablename__ = "bauwerksteil" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.bauwerksteil = bauwerksteil + + class trockenwetterfallrohr(bauwerksteil): + __tablename__ = "trockenwetterfallrohr" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.trockenwetterfallrohr = trockenwetterfallrohr + + class einstiegshilfe(bauwerksteil): + __tablename__ = "einstiegshilfe" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.einstiegshilfe = einstiegshilfe + + class trockenwetterrinne(bauwerksteil): + __tablename__ = "trockenwetterrinne" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.trockenwetterrinne = trockenwetterrinne + + class deckel(bauwerksteil): + __tablename__ = "deckel" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.deckel = deckel + + class bankett(bauwerksteil): + __tablename__ = "bankett" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.bankett = bankett + + # TEXTS + + class textpos(baseclass): + __tablename__ = "textpos" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.textpos = textpos + + class sia405_textpos(textpos): + __tablename__ = "sia405_textpos" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.sia405_textpos = sia405_textpos + + class haltung_text(sia405_textpos): + __tablename__ = "haltung_text" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.haltung_text = haltung_text + + class abwasserbauwerk_text(sia405_textpos): + __tablename__ = "abwasserbauwerk_text" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisSia405Abwasser.abwasserbauwerk_text = abwasserbauwerk_text diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_vsa_kek.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_vsa_kek.py new file mode 100644 index 000000000..767e74dad --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_interlis_vsa_kek.py @@ -0,0 +1,49 @@ +from .. import config +from .model_interlis_sia405_abwasser import ModelInterlisSia405Abwasser + + +class ModelInterlisVsaKek(ModelInterlisSia405Abwasser): + def __init__(self): + super().__init__() + + class erhaltungsereignis(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "erhaltungsereignis" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisVsaKek.erhaltungsereignis = erhaltungsereignis + + class untersuchung(ModelInterlisVsaKek.erhaltungsereignis): + __tablename__ = "untersuchung" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisVsaKek.untersuchung = untersuchung + + class schaden(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "schaden" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisVsaKek.schaden = schaden + + class normschachtschaden(schaden): + __tablename__ = "normschachtschaden" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisVsaKek.normschachtschaden = normschachtschaden + + class kanalschaden(schaden): + __tablename__ = "kanalschaden" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisVsaKek.kanalschaden = kanalschaden + + class datentraeger(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "datentraeger" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisVsaKek.datentraeger = datentraeger + + class datei(ModelInterlisSia405Abwasser.vsa_baseclass): + __tablename__ = "datei" + __table_args__ = {"schema": config.ABWASSER_SCHEMA} + + ModelInterlisVsaKek.datei = datei diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_tww_od.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_tww_od.py new file mode 100644 index 000000000..ea335343f --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_tww_od.py @@ -0,0 +1,142 @@ +from ...interlis import config +from .model_base import ModelBase + + +class ModelTwwOd(ModelBase): + def __init__(self): + super().__init__(config.TWW_OD_SCHEMA) + + class wastewater_structure(self.Base): + __tablename__ = "wastewater_structure" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.wastewater_structure = wastewater_structure + + class channel(wastewater_structure): + __tablename__ = "channel" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.channel = channel + + class manhole(wastewater_structure): + __tablename__ = "manhole" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.manhole = manhole + + class discharge_point(wastewater_structure): + __tablename__ = "discharge_point" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.discharge_point = discharge_point + + class special_structure(wastewater_structure): + __tablename__ = "special_structure" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.special_structure = special_structure + + class infiltration_installation(wastewater_structure): + __tablename__ = "infiltration_installation" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.infiltration_installation = infiltration_installation + + class wastewater_networkelement(self.Base): + __tablename__ = "wastewater_networkelement" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.wastewater_networkelement = wastewater_networkelement + + class reach_point(self.Base): + __tablename__ = "reach_point" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.reach_point = reach_point + + class wastewater_node(wastewater_networkelement): + __tablename__ = "wastewater_node" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.wastewater_node = wastewater_node + + class reach(wastewater_networkelement): + __tablename__ = "reach" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.reach = reach + + # class structure_part(wastewater_structure): + class structure_part(self.Base): + __tablename__ = "structure_part" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.structure_part = structure_part + + class dryweather_downspout(structure_part): + __tablename__ = "dryweather_downspout" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.dryweather_downspout = dryweather_downspout + + class access_aid(structure_part): + __tablename__ = "access_aid" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.access_aid = access_aid + + class dryweather_flume(structure_part): + __tablename__ = "dryweather_flume" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.dryweather_flume = dryweather_flume + + class cover(structure_part): + __tablename__ = "cover" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.cover = cover + + class benching(structure_part): + __tablename__ = "benching" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.benching = benching + + class wwtp_structure(wastewater_structure): + __tablename__ = "wwtp_structure" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.wwtp_structure = wwtp_structure + + # VSA_KEK + + class maintenance_event(self.Base): + __tablename__ = "maintenance_event" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.maintenance_event = maintenance_event + + class examination(maintenance_event): + __tablename__ = "examination" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.examination = examination + + class damage(self.Base): + __tablename__ = "damage" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.damage = damage + + class damage_manhole(damage): + __tablename__ = "damage_manhole" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.damage_manhole = damage_manhole + + class damage_channel(damage): + __tablename__ = "damage_channel" + __table_args__ = {"schema": config.TWW_OD_SCHEMA} + + ModelTwwOd.damage_channel = damage_channel diff --git a/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_tww_vl.py b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_tww_vl.py new file mode 100644 index 000000000..b9c0e4698 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/interlis_model_mapping/model_tww_vl.py @@ -0,0 +1,7 @@ +from ...interlis import config +from .model_base import ModelBase + + +class ModelTwwVl(ModelBase): + def __init__(self): + super().__init__(config.TWW_VL_SCHEMA) diff --git a/plugin/teksi_wastewater/interlis/processing_algs/__init__.py b/plugin/teksi_wastewater/interlis/processing_algs/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/plugin/teksi_wastewater/interlis/processing_algs/extractlabels_interlis.py b/plugin/teksi_wastewater/interlis/processing_algs/extractlabels_interlis.py new file mode 100644 index 000000000..5620ce98d --- /dev/null +++ b/plugin/teksi_wastewater/interlis/processing_algs/extractlabels_interlis.py @@ -0,0 +1,214 @@ +import json +import os +import tempfile +import uuid +from functools import partial + +from PyQt5.QtCore import QCoreApplication +from qgis import processing +from qgis.core import ( + QgsProcessingContext, + QgsProcessingFeedback, + QgsProcessingParameterBoolean, + QgsProcessingParameterEnum, + QgsProcessingParameterFileDestination, + QgsProcessingParameterVectorLayer, + QgsWkbTypes, +) + +from ...processing_provider.tww_algorithm import TwwAlgorithm +from ...utils.twwlayermanager import TwwLayerManager + + +class ExtractlabelsInterlisAlgorithm(TwwAlgorithm): + """This runs the native extractlabels algorithm for the given scales, and attaches obj_id and scale to the results. + + Otherwise, the output is difficult to use, because the FeatureID isn't stable (since it's the primary + key of the reach and structure views is not an integer)""" + + tr = partial(QCoreApplication.translate, "ExtractlabelsInterlisAlgorithm") + AVAILABLE_SCALES = [ + # ili key, display name, scale value + ("Leitungskataster", tr("Leitungskataster"), 1000), # TODO: check scale ? + ("Werkplan", tr("Werkplan"), 500), # TODO: check scale ? + ("Uebersichtsplan.UeP10", tr("Uebersichtsplan 1:10000"), 10000), + ("Uebersichtsplan.UeP5", tr("Uebersichtsplan 1:5000"), 5000), + ("Uebersichtsplan.UeP2", tr("Uebersichtsplan 1:2000"), 2000), + ] + + OUTPUT = "OUTPUT" + INPUT_RESTRICT_TO_SELECTION = "RESTRICT_TO_SELECTION" + INPUT_SCALES = "SCALES" + INPUT_STRUCTURE_VIEW_LAYER = "STRUCTURE_VIEW_LAYER" + INPUT_REACH_VIEW_LAYER = "REACH_VIEW_LAYER" + + def name(self): + return "extractlabels_interlis" + + def displayName(self): + return self.tr("Extract labels for interlis") + + def initAlgorithm(self, config=None): + self.addParameter( + QgsProcessingParameterFileDestination( + self.OUTPUT, + description=self.tr("Output labels file"), + fileFilter="geojson (*.geojson)", + ) + ) + + self.addParameter( + QgsProcessingParameterBoolean( + self.INPUT_RESTRICT_TO_SELECTION, + description=self.tr("Restrict to selection"), + ) + ) + + self.addParameter( + QgsProcessingParameterEnum( + self.INPUT_SCALES, + description=self.tr("Scales to export"), + allowMultiple=True, + options=[f"{self.tr(i[1])} [1:{i[2]}]" for i in self.AVAILABLE_SCALES], + defaultValue=[i for i in range(len(self.AVAILABLE_SCALES))], + ) + ) + + self.addParameter( + QgsProcessingParameterVectorLayer( + self.INPUT_STRUCTURE_VIEW_LAYER, + description=self.tr("Structure view layer"), + types=[QgsWkbTypes.PointGeometry], + ) + ) + + self.addParameter( + QgsProcessingParameterVectorLayer( + self.INPUT_REACH_VIEW_LAYER, + description=self.tr("Reach view layer"), + types=[QgsWkbTypes.LineGeometry], + ) + ) + + def processAlgorithm( + self, parameters, context: QgsProcessingContext, feedback: QgsProcessingFeedback + ): + labels_file_path = self.parameterAsFileOutput(parameters, self.OUTPUT, context) + restrict_to_selection = self.parameterAsBoolean( + parameters, self.INPUT_RESTRICT_TO_SELECTION, context + ) + structure_view_layer = self.parameterAsVectorLayer( + parameters, self.INPUT_STRUCTURE_VIEW_LAYER, context + ) + reach_view_layer = self.parameterAsVectorLayer( + parameters, self.INPUT_REACH_VIEW_LAYER, context + ) + scales = [ + self.AVAILABLE_SCALES[i] + for i in self.parameterAsEnums(parameters, self.INPUT_SCALES, context) + ] + + # Clear the output file if it exists + if os.path.isfile(labels_file_path): + os.remove(labels_file_path) + + # Compute the extent + if restrict_to_selection: + extent = structure_view_layer.boundingBoxOfSelected() + extent.combineExtentWith(reach_view_layer.boundingBoxOfSelected()) + else: + extent = structure_view_layer.extent() + extent.combineExtentWith(reach_view_layer.extent()) + + # Store a mapping from FeatureID to obj_id (used below) + reach_feats = reach_view_layer.getFeatures() + structure_feats = structure_view_layer.getFeatures() + rowid_to_obj_id = { + "vw_tww_reach": {f.id(): f.attribute("obj_id") for f in reach_feats}, + "vw_tww_wastewater_structure": { + f.id(): f.attribute("obj_id") for f in structure_feats + }, + } + + annotated_paths = [] + + # Extract all labels at all scales + for scale_id, scale_display, scale_value in scales: + # Make an unique temporary name + unique = uuid.uuid4().hex + extract_path = os.path.join( + tempfile.gettempdir(), f"labels-{scale_id}_{unique}.geojson" + ) + + # Extract the labels + feedback.pushInfo(f"Extracting labels for scale {scale_display} [1:{scale_value}]") + processing.run( + "native:extractlabels", + { + "DPI": 96, # TODO: check what this changes + "EXTENT": extent, + "INCLUDE_UNPLACED": True, + "MAP_THEME": None, + "OUTPUT": extract_path, + "SCALE": scale_value, + }, + # this is a child algotihm + is_child_algorithm=True, + context=context, + feedback=feedback, + ) + + # Load the extracted labels + with open(extract_path) as extract_path_handle: + geojson = json.load(extract_path_handle) + + # Check that labels were generated + labels_count = len(geojson["features"]) + feedback.pushInfo(f"{labels_count} labels generated") + if labels_count == 0: + continue + + # Annotate features with tww_obj_id and scal + lyr_name_to_key = { + TwwLayerManager.layer( + "vw_tww_wastewater_structure" + ).name(): "vw_tww_wastewater_structure", + TwwLayerManager.layer("vw_tww_reach").name(): "vw_tww_reach", + } + for label in geojson["features"]: + layer_name = label["properties"]["Layer"] + # this is a non-TWW layer, we don't annotate it + if layer_name not in lyr_name_to_key: + continue + lyr = lyr_name_to_key[layer_name] + rowid = label["properties"]["FeatureID"] + label["properties"]["Layer"] = lyr + label["properties"]["tww_obj_id"] = rowid_to_obj_id[lyr][rowid] + label["properties"]["scale"] = scale_id + + # Save + annotated_path = extract_path + ".annotated.geojson" + with open(annotated_path, "w") as annotated_path_handle: + json.dump(geojson, annotated_path_handle) + + annotated_paths.append(annotated_path) + + # time.sleep(60) + + # Merge all scales to one geojson + feedback.pushInfo(f"Merging all labels ({annotated_paths}) to {labels_file_path}") + processing.run( + "native:mergevectorlayers", + { + "LAYERS": annotated_paths, + "OUTPUT": labels_file_path, + }, + # this is a child algotihm + is_child_algorithm=True, + context=context, + feedback=feedback, + ) + + feedback.setProgress(100) + + return {} diff --git a/plugin/teksi_wastewater/interlis/tpl/export.py.tpl b/plugin/teksi_wastewater/interlis/tpl/export.py.tpl new file mode 100644 index 000000000..a57935f99 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/tpl/export.py.tpl @@ -0,0 +1,65 @@ +from sqlalchemy.orm import Session +from geoalchemy2.functions import ST_Transform, ST_Force2D + +from .. import utils + +from .model_{{model_name}} import get_{{model_name}}_model +from .model_{{ilimodel_name}} import get_{{ilimodel_name}}_model + + +def {{model_name}}_export(): + + {{model_name|upper}} = get_{{model_name}}_model() + {{ilimodel_name|upper}} = get_{{ilimodel_name}}_model() + + {{model_name}}_session = Session(utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False) + {{ilimodel_name}}_session = Session(utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False) + tid_maker = utils.ili2db.TidMaker(id_attribute='obj_id') + + def create_metaattributes(row, session): + metaattribute = {{ilimodel_name|upper}}.metaattribute( + # FIELDS TO MAP TO {{ilimodel_name|upper}}.metaattribute + # --- metaattribute --- + # datenherr=row.REPLACE_ME, + # datenlieferant=row.REPLACE_ME, + # letzte_aenderung=row.REPLACE_ME, + # sia405_baseclass_metaattribute=row.REPLACE_ME, + # t_id=row.REPLACE_ME + # t_seq=row.REPLACE_ME, + ) + session.add(metaattribute) + +{% for class_from, classes_to in mapping.items() %} + print("Exporting {{model_name|upper}}.{{class_from.__name__}} -> {{classes_to|qualclassesnames}}") + for row in {{model_name}}_session.query({{model_name|upper}}.{{class_from.__name__}}): + +{% for src_table, fields in class_from|classfields %} + # {{src_table}} --- {{fields|join(", ")}} +{% endfor %} + +{% for class_to in classes_to %} +{% if class_to.__name__ == 'metaattribute' %} + create_metaattributes(row, session) +{% else %} + {{class_to.__name__}} = {{ilimodel_name|upper}}.{{class_to.__name__}}( +{% for dst_table, fields in class_to|classfields %} +{% if dst_table != '_rel_' and dst_table != '_bwrel_' %} + + # --- {{dst_table}} --- +{% for field in fields %} + # {{field.name}}=row.REPLACE_ME, # {{field.property.columns[0].type}} +{% endfor %} +{% endif %} +{% endfor %} + ) + {{ilimodel_name}}_session.add({{class_to.__name__}}) +{% endif %} +{% endfor %} + print(".", end="") + print("done") + +{% endfor %} + {{ilimodel_name}}_session.commit() + + {{model_name}}_session.close() + {{ilimodel_name}}_session.close() diff --git a/plugin/teksi_wastewater/interlis/tpl/import_.py.tpl b/plugin/teksi_wastewater/interlis/tpl/import_.py.tpl new file mode 100644 index 000000000..5632870ad --- /dev/null +++ b/plugin/teksi_wastewater/interlis/tpl/import_.py.tpl @@ -0,0 +1,51 @@ +from sqlalchemy.orm import Session +from geoalchemy2.functions import ST_Transform, ST_Force2D + +from .. import utils + +from .model_{{model_name}} import get_{{model_name}}_model +from .model_{{ilimodel_name}} import get_{{ilimodel_name}}_model + + +def {{model_name}}_import(): + + {{model_name|upper}} = get_{{model_name}}_model() + {{ilimodel_name|upper}} = get_{{ilimodel_name}}_model() + + {{ilimodel_name}}_session = Session(utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False) + {{model_name}}_session = Session(utils.tww_sqlalchemy.create_engine(), autocommit=False, autoflush=False) + +{% for class_to, classes_from in mapping.items() %} + print("Importing {{classes_from|qualclassesnames}} -> {{model_name|upper}}.{{class_to.__name__}}") +{% if classes_from|length == 1 %} + for row in {{ilimodel_name}}_session.query({{classes_from|qualclassesnames}}): +{% else %} + for row, {{classes_from[1:]|classesnames}} in {{ilimodel_name}}_session.query({{classes_from|qualclassesnames}}){% if classes_from|length > 1 %}.join({{classes_from[1:]|qualclassesnames}}){% endif %}: +{% endif %} + +{% for class_from in classes_from %} +{% for src_table, fields in class_from|classfields %} + # {{src_table}} --- {{fields|join(", ")}} +{% endfor %} + +{% endfor %} + {{class_to.__name__}} = {{model_name|upper}}.{{class_to.__name__}}( +{% for dst_table, fields in class_to|classfields %} +{% if dst_table != '_rel_' and dst_table != '_bwrel_' %} + + # --- {{dst_table}} --- +{% for field in fields %} + # {{field.name}}=row.REPLACE_ME, # {{field.property.columns[0].type}} +{% endfor %} +{% endif %} +{% endfor %} + ) + {{model_name}}_session.add({{class_to.__name__}}) + print(".", end="") + print("done") + +{% endfor %} + {{model_name}}_session.commit() + + {{model_name}}_session.close() + {{ilimodel_name}}_session.close() diff --git a/plugin/teksi_wastewater/interlis/tpl/mapping.py.tpl b/plugin/teksi_wastewater/interlis/tpl/mapping.py.tpl new file mode 100644 index 000000000..485c9589b --- /dev/null +++ b/plugin/teksi_wastewater/interlis/tpl/mapping.py.tpl @@ -0,0 +1,19 @@ +from .{{model_name}} import Classes as {{model_name|upper}} +from .{{ilimodel_name}} import Classes as {{ilimodel_name|upper}} + +{{model_name|upper}}_TO_{{ilimodel_name|upper}} = { + # ALREADY MAPPED +{% for class_from, classes_to in mapping.items() %} + {{model_name|upper}}.{{class_from.__name__}}: [{{classes_to|qualclassesnames}}], +{% endfor %} + + # AVAILABLE TABLES + # {{ILIMODEL|sort(attribute='__name__')|qualclassesnames}} + + # NOT YET MAPPED +{% for class_from in MODEL|sort(attribute='__name__') %} +{% if class_from not in mapping.keys() %} + # {{model_name|upper}}.{{class_from.__name__}}: [{{ilimodel_name|upper}}.REPLACE_ME], +{% endif %} +{% endfor %} +} diff --git a/plugin/teksi_wastewater/interlis/utils/__init__.py b/plugin/teksi_wastewater/interlis/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/plugin/teksi_wastewater/interlis/utils/ili2db.py b/plugin/teksi_wastewater/interlis/utils/ili2db.py new file mode 100644 index 000000000..1585b8104 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/utils/ili2db.py @@ -0,0 +1,196 @@ +import collections +import re +import xml.etree.ElementTree as ET +from types import SimpleNamespace + +from sqlalchemy.ext.automap import AutomapBase + +from ...libs.modelbaker.iliwrapper import globals, ili2dbutils +from .. import config +from .various import exec_, get_pgconf_as_ili_args, logger + + +class InterlisToolsException(Exception): + pass + + +class InterlisTools: + def __init__(self): + class BaseConfiguration: + java_path = None + + self.java_executable_path = ili2dbutils.get_java_path(BaseConfiguration()) + + stdout = SimpleNamespace() + stdout.emit = logger.info + stderr = SimpleNamespace() + stderr.emit = logger.error + + self.ili2pg_executable_path = ili2dbutils.get_ili2db_bin( + globals.DbIliMode.ili2pg, 4, stdout, stderr + ) + + def import_ili_schema( + self, schema, models, log_path, ext_columns_no_constraints=False, create_basket_col=False + ): + sql_ext_refs_cols = "" + if ext_columns_no_constraints: + sql_ext_refs_cols = "--sqlExtRefCols" + + create_basket_col_args = "" + if create_basket_col: + create_basket_col_args = "--createBasketCol" + + logger.info(f"ILIDB SCHEMAIMPORT INTO {schema}...") + exec_( + " ".join( + [ + f'"{self.java_executable_path}"', + "-jar", + f'"{self.ili2pg_executable_path}"', + "--schemaimport", + *get_pgconf_as_ili_args(), + "--dbschema", + f"{schema}", + "--setupPgExt", + "--createGeomIdx", + f"{sql_ext_refs_cols}", + "--createFk", + "--createFkIdx", + "--createTidCol", + "--importTid", + f"{create_basket_col_args}", + "--noSmartMapping", + "--defaultSrsCode", + "2056", + "--log", + f'"{log_path}"', + "--nameLang", + "de", + "--models", + f'"{";".join(models)}"', + ] + ) + ) + + def validate_xtf_data(self, xtf_file, log_path): + logger.info("VALIDATING XTF DATA...") + exec_( + f'"{self.java_executable_path}" -jar "{config.ILIVALIDATOR}" --log "{log_path}" "{xtf_file}"' + ) + + def import_xtf_data(self, schema, xtf_file, log_path): + logger.info("IMPORTING XTF DATA...") + exec_( + " ".join( + [ + f'"{self.java_executable_path}"', + "-jar", + f'"{self.ili2pg_executable_path}"', + "--import", + "--deleteData", + *get_pgconf_as_ili_args(), + "--dbschema", + f'"{schema}"', + "--disableValidation", + "--skipReferenceErrors", + "--createTidCol", + "--noSmartMapping", + "--defaultSrsCode", + "2056", + "--log", + f'"{log_path}"', + f'"{xtf_file}"', + ] + ) + ) + + def export_xtf_data(self, schema, xtf_file, log_path, model_name, export_model_name): + logger.info("EXPORT ILIDB...") + + # if optional export_model_name is set, add it to the args + if export_model_name: + export_model_name_args = ["--exportModels", export_model_name] + else: + export_model_name_args = [] + + exec_( + " ".join( + [ + f'"{self.java_executable_path}"', + "-jar", + f'"{self.ili2pg_executable_path}"', + "--export", + "--models", + f"{model_name}", + *export_model_name_args, + *get_pgconf_as_ili_args(), + "--dbschema", + f"{schema}", + "--disableValidation", + "--skipReferenceErrors", + "--createTidCol", + "--noSmartMapping", + "--defaultSrsCode", + "2056", + "--log", + f'"{log_path}"', + "--trace", + f'"{xtf_file}"', + ] + ) + ) + + @staticmethod + def get_xtf_models(xtf_file): + logger.info(f"GET XTF MODELS from {xtf_file}...") + + # from xml file + tree = ET.parse(xtf_file) + root = tree.getroot() + + def get_namespace(element): + m = re.match(r"\{.*\}", element.tag) + return m.group(0) if m else "" + + namespace = get_namespace(root) + + model_elements = root.findall("./{0}HEADERSECTION/{0}MODELS/{0}MODEL".format(namespace)) + + if not model_elements: + raise InterlisToolsException(f"Couldn't find any model into '{xtf_file}'") + + models = [] + for model_element in model_elements: + models.append(model_element.attrib.get("NAME", None)) + + return models + + +class TidMaker: + """ + Helper class that creates globally unique integer primary key forili2pg class (t_id) + from a a TWW id (obj_id or id). + """ + + def __init__(self, id_attribute="id"): + self._id_attr = id_attribute + self._autoincrementer = collections.defaultdict(lambda: len(self._autoincrementer)) + + def tid_for_row(self, row, for_class=None): + # tid are globally unique, while ids are only guaranteed unique per table, + # so include the base table in the key + # this finds the base class (the first parent class before sqlalchemy.ext.automap.Base) + class_for_id = row.__class__.__mro__[row.__class__.__mro__.index(AutomapBase) - 2] + key = (class_for_id, getattr(row, self._id_attr), for_class) + # was_created = key not in self._autoincrementer # just for debugging + tid = self._autoincrementer[key] + # if was_created: + # # just for debugging + # logger.info(f"created tid {tid} for {key}") + return tid + + def next_tid(self): + """Get an arbitrary unused tid""" + key = len(self._autoincrementer) + return self._autoincrementer[key] diff --git a/plugin/teksi_wastewater/interlis/utils/tww_sqlalchemy.py b/plugin/teksi_wastewater/interlis/utils/tww_sqlalchemy.py new file mode 100644 index 000000000..cbba57af3 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/utils/tww_sqlalchemy.py @@ -0,0 +1,106 @@ +import logging + +import sqlalchemy +from sqlalchemy import inspect +from sqlalchemy.ext.automap import generate_relationship +from sqlalchemy.orm import ColumnProperty + +from .various import get_pgconf + + +def create_engine(logger_name=None): + logging_args = {} + if logger_name: + handler = logging.FileHandler(f"tww_export.{logger_name}.log", mode="w") + handler.setLevel(logging.DEBUG) + logging.getLogger(f"sqlalchemy.engine.base.Engine.{logger_name}").addHandler(handler) + logging_args = {"logging_name": logger_name, "echo": True} + + pgconf = get_pgconf() + + return sqlalchemy.create_engine( + f"postgresql://{pgconf['user']}:{pgconf['password']}@{pgconf['host']}:{pgconf['port']}/{pgconf['dbname']}", + **logging_args, + ) + + +def custom_name_for_collection_relationship(base, local_cls, referred_cls, constraint): + # This customizes the name for backwards relation (uses the class name and it's fk column name), avoiding clashes for inherited classes. + # See https://stackoverflow.com/a/48288656/13690651 + return f"{referred_cls.__name__}__BWREL_{constraint.columns.keys()[0]}" + + +def custom_name_for_scalar_relationship(base, local_cls, referred_cls, constraint): + # This customizes the name for backwards relation (uses the fk column name), avoiding clashes for inherited classes. + # See https://stackoverflow.com/a/48288656/13690651 + return f"{constraint.columns.keys()[0]}__REL" + + +def custom_generate_relationship( + base, direction, return_fn, attrname, local_cls, referred_cls, **kw +): + """ + Skips creating backwards relations to avoid adding instances twice with session.merge + """ + # disabling type checks on all relations, allowing to flush subclasses instead of abstract classes in relations + # without requiring to configure polymorphism + kw["enable_typechecks"] = False + + # accept circular-dependencies (e.g. organisation.dataowner can be itself) + # see https://docs.sqlalchemy.org/en/20/orm/relationship_persistence.html#rows-that-point-to-themselves-mutually-dependent-rows) + if attrname in ["fk_dataowner__REL", "fk_provider__REL"]: + kw["post_update"] = True + + return generate_relationship( + base, direction, return_fn, attrname, local_cls, referred_cls, **kw + ) + + +def prepare_automap_base(base, schema): + """ + Prepares the automap base by reflecting all the fields with some specific configuration for relationship and population Base.classes with manually defined classes (which for some reason isn't done by default) + """ + + # DOESN'T WORK, BUT CACHING WOULD BE GOOD + # pickle_file = f'{__file__}.pickled' + # reflect = True + # if os.path.exists(pickle_file): + # with open(pickle_file, 'rb') as f: + # reflect = False + # base.metadata = pickle.load(f) + + base.prepare( + create_engine(), + reflect=True, + schema=schema, + name_for_collection_relationship=custom_name_for_collection_relationship, + name_for_scalar_relationship=custom_name_for_scalar_relationship, + generate_relationship=custom_generate_relationship, + ) + + # For some reason, automap_base doesn't add manually defined classes to Base.classes, + # so we do it manually here + def add_subclasses(Parent): + for subclass in Parent.__subclasses__(): + if subclass.__name__ not in base.classes: + base.classes[subclass.__name__] = subclass + add_subclasses(subclass) + + add_subclasses(base) + + # DOESN'T WORK, BUT CACHING WOULD BE GOOD + # with open(pickle_file, 'wb') as f: + # pickle.dump(base.metadata, f) + + +def copy_instance(instance): + """ + Creates a copy of an SQLAchely ORM instance. Dont forget to change (or nullify) the primary key. + """ + klass = instance.__class__ + mapper = inspect(klass) + new_instance = klass() + for attr in mapper.attrs: + if isinstance(attr, ColumnProperty): + setattr(new_instance, attr.key, getattr(instance, attr.key)) + return new_instance diff --git a/plugin/teksi_wastewater/interlis/utils/various.py b/plugin/teksi_wastewater/interlis/utils/various.py new file mode 100644 index 000000000..f09f3ca12 --- /dev/null +++ b/plugin/teksi_wastewater/interlis/utils/various.py @@ -0,0 +1,296 @@ +import collections +import configparser +import datetime +import logging +import os +import subprocess +import tempfile +import time +from typing import List + +from .. import config + + +class DeduplicatedLogger(logging.Logger): + """Logger that deduplicates messages + + Multiple subsequent logging with the same message/level will result in [repeated N times] + message instead of many lines. + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._last_message = None + self._repeated = 0 + + def _log(self, level, msg, args, exc_info=None, extra=None): + this_message = (level, msg) + if self._last_message is None or self._last_message != this_message: + if self._repeated > 0: + super()._log( + self._last_message[0], + f"[repeted {self._repeated} times]", + args, + exc_info, + extra, + ) + + super()._log(level, msg, args, exc_info, extra) + self._repeated = 0 + else: + self._repeated += 1 + self._last_message = this_message + + +logging.setLoggerClass(DeduplicatedLogger) +logger = logging.getLogger(__package__) + + +class CmdException(BaseException): + pass + + +def exec_(command, check=True, output_content=False): + logger.info(f"EXECUTING: {command}") + try: + proc = subprocess.run( + command, + check=True, + shell=True, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + ) + except subprocess.CalledProcessError as e: + if check: + logger.exception(e.output.decode("windows-1252" if os.name == "nt" else "utf-8")) + raise CmdException("Command errored ! See logs for more info.") + return e.output if output_content else e.returncode + return proc.stdout.decode().strip() if output_content else proc.returncode + + +def setup_test_db(template="full"): + """ + As initializing demo data can be a bit slow, + we do these steps in a Docker container then commit it to an image, so we can + start a clean database relatively quickly. + + We prepare two template databases : full, empty + And then copy those to config.PGDATABASE when needed to initialize an fresh db + for testing. + """ + + pgconf = get_pgconf() + + def dexec_(cmd, check=True): + return exec_(f"docker exec twwqwat {cmd}", check) + + docker_image = os.getenv("TWWQWAT2ILI_TESTDB_IMAGE", "postgis/postgis:13-3.2") + + logger.info(f"SETTING UP TWW/QWAT DATABASE [{docker_image}]...") + + r = exec_("docker inspect -f '{{.State.Running}}' twwqwat", check=False) + running = r == 0 + if running: + r = exec_("docker inspect -f {{.Config.Image}} twwqwat", output_content=True) + if r != docker_image: + logger.info(f"Test container running `{r}`, we expect `{docker_image}`, we kill it") + exec_("docker rm twwqwat --force") + running = False + + if not running: + logger.info("Test container not running, we create it") + exec_( + f"docker run -d --rm -p 5432:5432 --name twwqwat -e POSTGRES_PASSWORD={pgconf['password'] or 'postgres'} -e POSTGRES_DB={pgconf['dbname'] or 'tww_prod'} {docker_image}" + ) + + # Wait for PG + while exec_("docker exec twwqwat pg_isready", check=False) != 0: + logger.info("Postgres not ready... we wait...") + time.sleep(1) + + db_didnt_exist = ( + dexec_("createdb -U postgres tpl_empty", check=False) == 0 + or dexec_("createdb -U postgres tpl_full", check=False) == 0 + ) + if db_didnt_exist: + logger.info("Test templates don't exist, we create them") + + dexec_("dropdb -U postgres tpl_empty --if-exists") + dexec_("dropdb -U postgres tpl_full --if-exists") + + dexec_("apt-get update") + dexec_("apt-get install -y wget") + + # Getting data + dexec_( + "wget https://github.com/TWW/datamodel/releases/download/1.5.6-1/tww_1.5.6-1_structure_and_demo_data.backup" + ) + dexec_( + "wget https://github.com/TWW/datamodel/releases/download/1.5.6-1/tww_1.5.6-1_structure_with_value_lists.sql" + ) + dexec_( + "wget https://github.com/qwat/qwat-data-model/releases/download/1.3.6/qwat_v1.3.6_data_and_structure_sample.backup" + ) + dexec_( + "wget https://github.com/qwat/qwat-data-model/releases/download/1.3.6/qwat_v1.3.6_structure_only.sql" + ) + dexec_( + "wget https://github.com/qwat/qwat-data-model/releases/download/1.3.6/qwat_v1.3.6_value_list_data_only.sql" + ) + + # Creating the template DB with empty structure + dexec_("psql -f tww_1.5.6-1_structure_with_value_lists.sql tww_prod postgres") + dexec_("psql -f qwat_v1.3.6_structure_only.sql tww_prod postgres") + dexec_("psql -f qwat_v1.3.6_value_list_data_only.sql tww_prod postgres") + dexec_("createdb -U postgres --template=tww_prod tpl_empty") + + # Creating the template DB with full data + dexec_( + 'psql -U postgres -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE pid<>pg_backend_pid();"' + ) + dexec_("dropdb -U postgres tww_prod --if-exists") + dexec_("createdb -U postgres tww_prod") + dexec_( + "pg_restore -U postgres --dbname tww_prod --verbose --no-privileges --exit-on-error tww_1.5.6-1_structure_and_demo_data.backup" + ) + dexec_( + "pg_restore -U postgres --dbname tww_prod --verbose --no-privileges --exit-on-error qwat_v1.3.6_data_and_structure_sample.backup" + ) + dexec_("createdb -U postgres --template=tww_prod tpl_full") + + # Hotfix tww invalid demo data + delta_path = os.path.join( + os.path.dirname(__file__), "..", "data", "test_data", "tww_demodata_hotfix.sql" + ) + exec_(f"docker cp {delta_path} twwqwat:/tww_demodata_hotfix.sql") + dexec_("psql -U postgres -d tpl_full -v ON_ERROR_STOP=1 -f /tww_demodata_hotfix.sql") + + # Hotfix qwat invalid demo data + delta_path = os.path.join( + os.path.dirname(__file__), "..", "data", "test_data", "qwat_demodata_hotfix.sql" + ) + exec_(f"docker cp {delta_path} twwqwat:/qwat_demodata_hotfix.sql") + dexec_("psql -U postgres -d tpl_full -v ON_ERROR_STOP=1 -f /qwat_demodata_hotfix.sql") + + dexec_( + 'psql -U postgres -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE pid<>pg_backend_pid();"' + ) + dexec_("dropdb -U postgres tww_prod --if-exists") + dexec_(f"createdb -U postgres --template=tpl_{template} tww_prod") + + +def capfirst(s): + return s[0].upper() + s[1:] + + +def invert_dict(d): + return {v: k for k, v in d.items()} + + +def read_pgservice(service_name): + """ + Returns a config object from a pg_service name (parsed from PGSERVICEFILE). + """ + + # Path for pg_service.conf + if os.environ.get("PGSERVICEFILE"): + PG_CONFIG_PATH = os.environ.get("PGSERVICEFILE") + elif os.environ.get("PGSYSCONFDIR"): + PG_CONFIG_PATH = os.path.join(os.environ.get("PGSYSCONFDIR"), "pg_service.conf") + else: + PG_CONFIG_PATH = os.path.expanduser("~/.pg_service.conf") + + config = configparser.ConfigParser() + if os.path.exists(PG_CONFIG_PATH): + config.read(PG_CONFIG_PATH) + + if service_name not in config: + logger.warning(f"Service `{service_name}` not found in {PG_CONFIG_PATH}.") + return {} + + return config[service_name] + + +def get_pgconf(): + """ + Returns the postgres configuration (parsed from the config.PGSERVICE service and overriden by config.PG* settings) + """ + + if config.PGSERVICE: + pgconf = read_pgservice(config.PGSERVICE) + else: + pgconf = {} + + if config.PGHOST: + pgconf["host"] = config.PGHOST + if config.PGPORT: + pgconf["port"] = config.PGPORT + if config.PGDATABASE: + pgconf["dbname"] = config.PGDATABASE + if config.PGUSER: + pgconf["user"] = config.PGUSER + if config.PGPASS: + pgconf["password"] = config.PGPASS + + return collections.defaultdict(str, pgconf) + + +def get_pgconf_as_psycopg2_dsn() -> List[str]: + """Returns the pgconf as a psycopg2 connection string""" + + pgconf = get_pgconf() + parts = [] + if pgconf["host"]: + parts.append(f"host={pgconf['host']}") + if pgconf["port"]: + parts.append(f"port={pgconf['port']}") + if pgconf["user"]: + parts.append(f"dbname={pgconf['dbname']}") + if pgconf["password"]: + parts.append(f"user={pgconf['user']}") + if pgconf["dbname"]: + parts.append(f"password={pgconf['password']}") + return " ".join(parts) + + +def get_pgconf_as_ili_args() -> List[str]: + """Returns the pgconf as a list of ili2db arguments""" + pgconf = get_pgconf() + args = [] + if pgconf["host"]: + args.extend(["--dbhost", '"' + pgconf["host"] + '"']) + if pgconf["port"]: + args.extend(["--dbport", '"' + pgconf["port"] + '"']) + if pgconf["user"]: + args.extend(["--dbusr", '"' + pgconf["user"] + '"']) + if pgconf["password"]: + args.extend(["--dbpwd", '"' + pgconf["password"] + '"']) + if pgconf["dbname"]: + args.extend(["--dbdatabase", '"' + pgconf["dbname"] + '"']) + return args + + +def make_log_path(next_to_path, step_name): + """Returns a path for logging purposes. If next_to_path is None, it will be saved in the temp directory""" + now = f"{datetime.datetime.now():%y%m%d%H%M%S}" + if next_to_path: + return f"{next_to_path}.{now}.{step_name}.log" + else: + temp_path = os.path.join(tempfile.gettempdir(), "tww2ili") + os.makedirs(temp_path, exist_ok=True) + return os.path.join(temp_path, f"{now}.{step_name}.log") + + +class LoggingHandlerContext: + """Temporarily sets a log handler, then removes it""" + + def __init__(self, handler): + self.handler = handler + + def __enter__(self): + logger.addHandler(self.handler) + + def __exit__(self, et, ev, tb): + logger.removeHandler(self.handler) + self.handler.close() + # implicit return of None => don't swallow exceptions diff --git a/plugin/teksi_wastewater/metadata.txt b/plugin/teksi_wastewater/metadata.txt new file mode 100644 index 000000000..1787ee2c3 --- /dev/null +++ b/plugin/teksi_wastewater/metadata.txt @@ -0,0 +1,20 @@ + +[general] +name=TEKSI Wastewater +description=Plugin to manage wastewater networks (formerly: QGEP) # // skip-keyword-check +qgisMinimumVersion=3.2 +category=Vector +version=0.0.0 + +changelog=See repository for full changelog +tags=teksi, gep, abwasser, wastewater, qgep, assainissement # // skip-keyword-check +author=TEKSI +email=info@teksi.ch +about=The TEKSI wastewater plugin adds functionality to manage wastewater networks in QGIS. It was formerly known as QGEP. # // skip-keyword-check +homepage=https://www.teksi.ch/modules/abwasser-gep/ +tracker=https://github.com/teksi/teksi_wastewater/issues +repository=https://github.com/teksi/teksi_wastewater +icon=icons/teksi-abwasser-logo.svg + +experimental=False +deprecated=False diff --git a/plugin/teksi_wastewater/processing_provider/TwwSwmm.py b/plugin/teksi_wastewater/processing_provider/TwwSwmm.py new file mode 100644 index 000000000..2a344125a --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/TwwSwmm.py @@ -0,0 +1,1303 @@ +""" +/*************************************************************************** + TWW-swmm processing provider + ------------------- + begin : 07.2019 + copyright : (C) 2019 by ig-group.ch + email : timothee.produit@ig-group.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +import codecs +import subprocess +from datetime import datetime, timedelta + +import psycopg2 + +MEASURING_POINT_KIND = "Diverse kind of SWMM simulation parameters" +MEASURING_DEVICE_REMARK = "SWMM Simulation" + +SWMM_SUMMARY_PARAMETERS = {} +SWMM_SUMMARY_PARAMETERS["average_depth"] = { + "recorded": True, + "dimension": "m", + "tww_measurement_type": 5734, +} +SWMM_SUMMARY_PARAMETERS["maximum_depth"] = { + "recorded": True, + "dimension": "m", + "tww_measurement_type": 5734, +} +SWMM_SUMMARY_PARAMETERS["maximum_hgl"] = { + "recorded": True, + "dimension": "m", + "tww_measurement_type": 5732, +} +SWMM_SUMMARY_PARAMETERS["reported_max_depth"] = { + "recorded": True, + "dimension": "m", + "tww_measurement_type": 5734, +} +SWMM_SUMMARY_PARAMETERS["maximum_flow"] = { + "recorded": True, + "dimension": "l/s", + "tww_measurement_type": 5733, +} +SWMM_SUMMARY_PARAMETERS["maximum_velocity"] = { + "recorded": True, + "dimension": "m/s", + "tww_measurement_type": 5732, +} +SWMM_SUMMARY_PARAMETERS["max_over_full_flow"] = { + "recorded": True, + "dimension": "-", + "tww_measurement_type": 5733, +} +SWMM_SUMMARY_PARAMETERS["max_over_full_depth"] = { + "recorded": True, + "dimension": "-", + "tww_measurement_type": 5734, +} + +SWMM_RESULTS_PARAMETERS = {} +SWMM_RESULTS_PARAMETERS["flow"] = { + "recorded": True, + "dimension": "l/s", + "tww_measurement_type": 5733, +} +SWMM_RESULTS_PARAMETERS["velocity"] = { + "recorded": True, + "dimension": "m/s", + "tww_measurement_type": 5732, +} +SWMM_RESULTS_PARAMETERS["depth"] = { + "recorded": True, + "dimension": "m", + "tww_measurement_type": 5734, +} +SWMM_RESULTS_PARAMETERS["capacity"] = { + "recorded": True, + "dimension": "-", + "tww_measurement_type": 5732, +} +SWMM_RESULTS_PARAMETERS["inflow"] = { + "recorded": True, + "dimension": "l/s", + "tww_measurement_type": 5733, +} +SWMM_RESULTS_PARAMETERS["flooding"] = { + "recorded": True, + "dimension": "l/s", + "tww_measurement_type": 5733, +} +SWMM_RESULTS_PARAMETERS["head"] = { + "recorded": True, + "dimension": "m", + "tww_measurement_type": 5732, +} + +NON_PHYSICAL_REM = "Non-physical point which materializes swmm simulations" + + +class TwwSwmm: + def __init__(self, title, service, state, inpfile, inptemplate, rptfile, binfile, feedback): + """ + Initiate TwwSwmm + + Parameters: + title (string): Title of the simulation + service (string): name of the service to be used to connect to the TWW database + state (string): state for which the network is extracted (current or planned) + inpfile (path): path of the INP file (input file for swmm) + inptemplate (path): path of the INP file which store simulations parameters + rptfile (path): path of the OUT file which contains swmm results + binfile (path): path of the swmm executable + feedback (pyQGIS feedback) + """ + self.title = title + self.service = service + self.input_file = inpfile + self.options_template_file = inptemplate + self.rpt_file = rptfile + self.bin_file = binfile + self.feedback = feedback + self.state = state + + def __enter__(self): + if self.service is not None: + self.con = psycopg2.connect(service=self.service) + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + if self.service is not None: + del self.con + + def feedback_push(self, level, message): + if self.feedback is not None and message != "" and message is not None: + if level == "info": + self.feedback.pushInfo(message) + elif level == "warning": + self.feedback.pushWarning(message) + elif level == "error": + self.feedback.reportError(message) + else: + self.feedback.pushInfo(message) + return + + def feedback_set_progress(self, progress): + if self.feedback is not None: + self.feedback.setProgress(progress) + return + + def get_swmm_table(self, table_name, state, selected_structures, hierarchy): + """ + Extract data from the swmm views in the database + + Parameters: + table_name (string): Name of the view or table + state (string): current or planned + selected_structures ([string]): List of obj_id of the selected structures + + Returns: + dic: table content + array: table attributes + + """ + + # Connects to service and get data and attributes from tableName + cur = self.con.cursor() + + # Configure the filters + where_clauses = [] + if state == "planned": + where_clauses.append("(state = 'planned' OR state = 'current')") + elif state == "current": + where_clauses.append("state = 'current'") + if selected_structures: + where_clauses.append( + """ + obj_id in ('{ids}') + """.format( + ids="','".join(selected_structures) + ) + ) + if hierarchy: + where_clauses.append(f"""hierarchy = '{hierarchy}'""") + + sql = """ + select * from tww_swmm.vw_{table_name} + """.format( + table_name=table_name + ) + # Add the filters to the sql + if len(where_clauses) > 0: + sql = """ + {sql} where {where_clauses} + """.format( + sql=sql, where_clauses=" AND ".join(where_clauses) + ) + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while executing: {sql}") + return None, None + self.feedback_push("info", f"Process vw_{table_name}") + data = cur.fetchall() + attributes = [desc[0] for desc in cur.description] + del cur + + return data, attributes + + def swmm_table(self, table_name, hierarchy=None, state=None, selected_structures=[]): + """ + Write swmm objects extracted from TWW in swmm input file. Selects according + to the state planned or current. If the object is a teksi wastewater structure + when the state is "planned" both "planned" and "operational" wastewater structures are selected + + Parameters: + table_name (string): Name of the swmm section + state (string): current or planned + selected_structre ([string]). List of obj_id of the selected wastewater structures + ws (boolean): if the origin table is a wastewater structure + + Returns: + String: table content + + """ + notPrintedFields = [ + "description", + "tag", + "geom", + "state", + "ws_obj_id", + "hierarchy", + "message", + ] + # Create commented line which contains the field names + fields = "" + data, attributes = self.get_swmm_table(table_name, state, selected_structures, hierarchy) + if data is not None: + for i, field in enumerate(attributes): + # Does not write values stored in columns descriptions, tags and geom + if field not in notPrintedFields: + fields += field + "\t" + + # Create input paragraph + tbl = "[" + table_name + "]\n" ";;" + fields + "\n" + for feature in data: + for i, v in enumerate(feature): + # Write description + if attributes[i] == "description" and v is not None: + tbl += ";" + tbl += str(v) + tbl += "\n" + + for i, v in enumerate(feature): + # Does not write values stored in columns descriptions, tags and geom + if attributes[i] not in notPrintedFields: + if v is not None: + tbl += str(v) + "\t" + else: + tbl += "\t" + if attributes[i] == "message" and v != "": + self.feedback_push("warning", v) + tbl += "\n" + tbl += "\n" + return tbl + else: + return "\n" + + def copy_parameters_from_template(self, parameter_name): + """ + Write swmm objects extracted from template in swmm input file + + Parameters: + parameter_name (string): Name of the swmm section to be copied + + Returns: + String: section content + + """ + # Read template + options_template = open(self.options_template_file).read() + # Find and extract options + index_start = options_template.find(f"[{parameter_name}]") + if index_start == -1: + # The balise options is not found + self.feedback_push( + "info", + "There is no {parameter_name} in the template file".format( + parameter_name=parameter_name + ), + ) + return "" + else: + # Search for the next opening bracket + index_stop = options_template[index_start + 1 :].find("[") + if index_stop == -1: + # Copies text until the end of the file + index_stop = len(options_template) + option_text = options_template[index_start:index_stop] + "\n\n" + else: + index_stop = index_start + 1 + index_stop + option_text = options_template[index_start:index_stop] + return option_text + + def write_input(self, hierarchy, selected_structures, selected_reaches): + """ + Write the swmm input file + + """ + + # From qgis swmm + filename = self.input_file + state = self.state + + selected_ws_re = None + if selected_structures and selected_reaches: + selected_ws_re = selected_structures + selected_reaches + + with codecs.open(filename, "w", encoding="utf-8") as f: + # Title / Notes + # -------------- + f.write("[TITLE]\n") + f.write(self.title + "\n\n") + + # Options + # -------- + f.write(self.copy_parameters_from_template("OPTIONS")) + f.write(self.copy_parameters_from_template("REPORT")) + f.write(self.copy_parameters_from_template("FILES")) + f.write(self.copy_parameters_from_template("EVENTS")) + + # Climatology + # ------------ + f.write(self.copy_parameters_from_template("HYDROGRAPHS")) + f.write(self.copy_parameters_from_template("EVAPORATION")) + f.write(self.copy_parameters_from_template("TEMPERATURE")) + + # Hydrology + # ---------- + self.feedback_set_progress(5) + f.write(self.swmm_table("RAINGAGES", hierarchy, state, selected_structures)) + f.write(self.swmm_table("SYMBOLS", hierarchy, state, selected_structures)) + self.feedback_set_progress(10) + f.write(self.swmm_table("SUBCATCHMENTS", hierarchy, state, selected_structures)) + self.feedback_set_progress(15) + f.write(self.swmm_table("SUBAREAS", hierarchy, state, selected_structures)) + self.feedback_set_progress(20) + f.write(self.swmm_table("AQUIFERS")) + self.feedback_set_progress(25) + f.write(self.swmm_table("INFILTRATION", hierarchy, state, selected_structures)) + self.feedback_set_progress(30) + f.write(self.swmm_table("POLYGONS")) + + f.write(self.copy_parameters_from_template("GROUNDWATER")) + f.write(self.copy_parameters_from_template("SNOWPACKS")) + f.write(self.copy_parameters_from_template("HYDROGAPHS")) + f.write(self.copy_parameters_from_template("LID_CONTROLS")) + f.write(self.copy_parameters_from_template("LID_USAGE")) + + # Hydraulics: nodes + # ------------------ + self.feedback_set_progress(35) + f.write(self.swmm_table("JUNCTIONS", hierarchy, state, selected_ws_re)) + self.feedback_set_progress(40) + f.write(self.swmm_table("OUTFALLS", hierarchy, state, selected_structures)) + self.feedback_set_progress(45) + f.write(self.swmm_table("STORAGES", hierarchy, state, selected_structures)) + self.feedback_set_progress(50) + f.write(self.swmm_table("COORDINATES", hierarchy, state, selected_ws_re)) + self.feedback_set_progress(55) + f.write(self.swmm_table("DWF", hierarchy, state, selected_structures)) + + f.write(self.copy_parameters_from_template("INFLOWS")) + f.write(self.swmm_table("DIVIDERS")) + + # Hydraulics: links + # ------------------ + self.feedback_set_progress(60) + f.write(self.swmm_table("CONDUITS", hierarchy, state, selected_reaches)) + self.feedback_set_progress(65) + f.write(self.swmm_table("LOSSES", hierarchy, state, selected_structures)) + self.feedback_set_progress(70) + f.write(self.swmm_table("PUMPS", hierarchy, state, selected_structures)) + f.write(self.swmm_table("ORIFICES", hierarchy, state, selected_structures)) + f.write(self.swmm_table("WEIRS", hierarchy, state, selected_structures)) + self.feedback_set_progress(75) + f.write(self.swmm_table("XSECTIONS", hierarchy, state, selected_reaches)) + self.feedback_set_progress(80) + f.write(self.swmm_table("LOSSES", hierarchy, state, selected_structures)) + f.write(self.swmm_table("OUTLETS")) + self.feedback_set_progress(85) + f.write(self.swmm_table("VERTICES", hierarchy, state, selected_reaches)) + f.write(self.copy_parameters_from_template("TRANSECTS")) + f.write(self.copy_parameters_from_template("CONTROLS")) + + # Quality + # -------- + self.feedback_set_progress(90) + f.write(self.swmm_table("LANDUSES")) + self.feedback_set_progress(93) + f.write(self.swmm_table("COVERAGES", None, None, selected_structures)) + + f.write(self.copy_parameters_from_template("POLLUTANTS")) + f.write(self.copy_parameters_from_template("BUILDUP")) + f.write(self.copy_parameters_from_template("WASHOFF")) + f.write(self.copy_parameters_from_template("TREATMENT")) + f.write(self.copy_parameters_from_template("RDII")) + f.write(self.copy_parameters_from_template("LOADINGS")) + + # Curves + # ------- + f.write(self.swmm_table("CURVES")) + + # Time series + # ------------ + f.write(self.copy_parameters_from_template("TIMESERIES")) + + # Time patterns + # -------------- + f.write(self.copy_parameters_from_template("PATTERNS")) + + # Map labels + # ----------- + f.write(self.copy_parameters_from_template("LABELS")) + self.feedback_set_progress(96) + + # Tags + # ---- + f.write(self.swmm_table("TAGS", state, selected_ws_re)) + f.close() + return + + def extract_time_series_indexes(self): + """ + Extract full time series from swmm report file + + Returns: + data_indexes (dictionary): dictionary of the object id with data indexes + + """ + + o = codecs.open(self.rpt_file, "r", encoding="utf-8") + line = o.readline() + title_found = False + line_number = -1 + data_indexes = {} + heading_lines = 5 + while line: + line_number += 1 + line = line.rstrip() + # Search for the table title + if line.find("*****") != -1: + # The following title is found: stop the recording of the indexes + title_found = False + + if line.find("<<< Link ") != -1 or line.find("<<< Node ") != -1: + title_found = True + line_after_title = 0 + obj_id = line.strip().split(" ")[2] + data_indexes[obj_id] = {} + data_indexes[obj_id]["title_index"] = line_number + data_indexes[obj_id]["start_index"] = line_number + heading_lines + if line.find("Link") != -1: + data_indexes[obj_id]["type"] = "link" + if line.find("Node") != -1: + data_indexes[obj_id]["type"] = "node" + + if title_found and line_after_title > heading_lines and line.strip() == "": + data_indexes[obj_id]["end_index"] = line_number - 1 + + if title_found: + line_after_title += 1 + + line = o.readline() + o.close() + return data_indexes + + def extract_summary_lines(self, table_title): + """ + Extract result data from swmm report file + + Parameters: + table_title (string): Name of the section to be extracted + + Returns: + Array of array: Extracted computed values + + """ + + o = codecs.open(self.rpt_file, "r", encoding="utf-8") + + line = o.readline() + no_line = 0 + lines = [] + title_found = False + end_table_found = False + while line: + line = line.rstrip() + # Search for the table title + if line.find(table_title) != -1: + title_found = True + line_after_title = 0 + + if title_found and line_after_title > 7 and line == "": + end_table_found = True + + if title_found and end_table_found is False and line_after_title > 7: + lines.append(line.split()) + + if title_found: + line_after_title += 1 + + no_line += 1 + line = o.readline() + o.close() + + return lines + + def extract_node_depth_summary(self): + """ + Extract node depth result data from swmm output file + + Returns: + dic: Extracted computed values + + """ + + data = self.extract_summary_lines("Node Depth Summary") + result = [] + for d in data: + curres = {} + curres["id"] = d[0] + curres["type"] = d[1] + curres["average_depth"] = d[2] + curres["maximum_depth"] = d[3] + curres["maximum_hgl"] = d[4] + curres["time_max_day"] = d[5] + curres["time_max_time"] = d[6] + curres["reported_max_depth"] = d[7] + result.append(curres) + return result + + def extract_link_flow_summary(self): + """ + Extract link flow result data from swmm output file + + Returns: + dic: Extracted computed values + + """ + + data = self.extract_summary_lines("Link Flow Summary") + result = [] + for d in data: + curres = {} + curres["id"] = d[0] + curres["type"] = d[1] + curres["maximum_flow"] = d[2] + curres["time_max_day"] = d[3] + curres["time_max_time"] = d[4] + if d[1] == "CONDUIT": + curres["maximum_velocity"] = d[5] + curres["max_over_full_flow"] = d[6] + curres["max_over_full_depth"] = d[7] + elif d[1] == "PUMP": + curres["max_over_full_flow"] = d[5] + curres["maximum_velocity"] = None + curres["max_over_full_depth"] = None + + result.append(curres) + return result + + def execute_swmm(self): + """ + Execute SWMM + + Parameters: + dic: Extracted computed values + + """ + + command = [self.bin_file, self.input_file, self.rpt_file] + self.feedback_push("info", "command: " + " ".join(map(str, command))) + proc = subprocess.run( + command, + shell=True, + stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + ).stdout + + return proc + + def get_analysis_option(self, parameter): + o = codecs.open(self.rpt_file, "r", encoding="utf-8") + line = o.readline() + while line: + line = line.rstrip() + # Search for the analyis option + if line.find(parameter) != -1: + value = line.split(".")[-1].strip() + line = o.readline() + o.close() + return value + + def convert_to_datetime(self, str_date): + date = datetime.strptime(str_date, "%d/%m/%Y %H:%M:%S") + return date + + def import_full_results(self, sim_description): + """ + Import the full results from an SWMM report file + + Parameters: + sim_description (string): Title of the simulation + + """ + + simulation_start_date = self.convert_to_datetime(self.get_analysis_option("Starting Date")) + simulation_end_date = self.convert_to_datetime(self.get_analysis_option("Ending Date")) + simulation_duration = simulation_end_date - simulation_start_date + measuring_duration = simulation_duration.total_seconds() + + data_indexes = self.extract_time_series_indexes() + + ndata = len(data_indexes.keys()) + self.feedback_push("info", "Import full results") + counter = 0 + for obj_id in data_indexes.keys(): + counter += 1 + self.feedback_set_progress(counter * 100 / ndata) + # Create measuring point if necessary + if data_indexes[obj_id]["type"] == "node": + mp_obj_id = self.create_measuring_point_node(obj_id, sim_description) + if data_indexes[obj_id]["type"] == "link": + mp_obj_id = self.create_measuring_point_link(obj_id, sim_description) + if mp_obj_id: + # Create measuring device + self.create_measuring_device(mp_obj_id) + # Get measurement data of the current object + measurement_data = self.get_full_results( + data_indexes[obj_id]["start_index"], + data_indexes[obj_id]["end_index"], + data_indexes[obj_id]["type"], + ) + # Record each measurement + m_counter = 0 + for m in measurement_data: + m_counter += 1 + time = self.convert_to_datetime(m["date"] + " " + m["time"]).isoformat() + for k in m.keys(): + if k in SWMM_RESULTS_PARAMETERS.keys(): + if SWMM_RESULTS_PARAMETERS[k]["recorded"]: + ms_obj_id = self.create_measurement_series( + mp_obj_id, + k, + SWMM_RESULTS_PARAMETERS[k]["dimension"], + ) + self.create_measurement_result( + ms_obj_id, + SWMM_RESULTS_PARAMETERS[k]["tww_measurement_type"], + measuring_duration, + time, + m[k], + ) + return + + def get_full_results(self, start_index, end_index, swmm_type): + """ + Get the full result of a node or link + + Parameters: + start_index (integer): Index of the first line containing the data + end_index (integer): Index of the last line containing the data + + Returns: + datas: array of dictionnary containing the data + """ + o = codecs.open(self.rpt_file, "r", encoding="utf-8") + line = o.readline() + no_line = -1 + datas = [] + while line: + no_line += 1 + if no_line >= start_index and no_line < end_index: + values = line.strip().split() + data = {} + if len(values) != 0: + data["date"] = values[0] + data["time"] = values[1] + if swmm_type == "node": + data["inflow"] = values[2] + data["flooding"] = values[3] + data["depth"] = values[4] + data["head"] = values[5] + if swmm_type == "link": + data["flow"] = values[2] + data["velocity"] = values[3] + data["depth"] = values[4] + data["capacity"] = values[5] + datas.append(data) + line = o.readline() + o.close() + return datas + + def import_summary(self, sim_description): + """ + Import the summary results from an SWMM report file + + Parameters: + sim_description (string): Title of the simulation + + """ + simulation_start_date = self.convert_to_datetime(self.get_analysis_option("Starting Date")) + simulation_end_date = self.convert_to_datetime(self.get_analysis_option("Ending Date")) + simulation_duration = simulation_end_date - simulation_start_date + measuring_duration = simulation_duration.total_seconds() + self.feedback_push("info", "Import nodes summary") + node_summary = self.extract_node_depth_summary() + self.record_summary( + node_summary, + simulation_start_date, + sim_description, + measuring_duration, + "node", + ) + self.feedback_push("info", "Import links summary") + link_summary = self.extract_link_flow_summary() + self.record_summary( + link_summary, + simulation_start_date, + sim_description, + measuring_duration, + "link", + ) + + return + + def convert_max_over_full_flow(self, link_summary): + """ + Convert max_over_full_flow in percent + + Parameters: + link_summary (array): data extracted from the summary + + Returns: + link_summary (array) + """ + + for ws in link_summary: + ws["max_over_full_flow"] = int(round(float(ws["max_over_full_flow"]))) * 100 + + return link_summary + + def import_backflow_level(self): + """ + Import the backflow level from an SWMM report file + """ + self.feedback_push("info", "Import backflow level") + print("1") + node_summary = self.extract_node_depth_summary() + print("2") + self.populate_attribute(node_summary, "wastewater_node", "backflow_level", "maximum_hgl") + + return + + def import_hydraulic_load(self): + """ + Import the hydraulic load from an SWMM report file + """ + self.feedback_push("info", "Import hydraulic load") + link_summary = self.extract_link_flow_summary() + link_summary = self.convert_max_over_full_flow(link_summary) + self.populate_attribute( + link_summary, + "reach", + "dss2020_hydraulic_load_current", + "max_over_full_flow", + ) + + return + + def record_summary( + self, data, simulation_start_date, sim_description, measuring_duration, obj_type + ): + """ + Record the node and link summary in the database + + Parameters: + data (array): data extracted from the summary + simulation_start_date (datetime): start of the simulation + sim_description (string): name of the simulation + measuring_duration (integer): time length of the simulation in seconds + obj_type (string): link or node + + """ + + ndata = len(data) + # Loop over each line of the node summary + counter = 0 + for ws in data: + counter += 1 + if obj_type == "node": + self.feedback_set_progress(counter * 50 / ndata) + mp_obj_id = self.create_measuring_point_node(ws["id"], sim_description) + else: + self.feedback_set_progress(50 + counter * 50 / ndata) + mp_obj_id = self.create_measuring_point_link(ws["id"], sim_description) + if mp_obj_id: + self.create_measuring_device(mp_obj_id) + delta = timedelta( + days=int(ws["time_max_day"]), + hours=int(ws["time_max_time"].split(":")[0]), + minutes=int(ws["time_max_time"].split(":")[1]), + ) + for k in ws.keys(): + if k in SWMM_SUMMARY_PARAMETERS.keys(): + if SWMM_SUMMARY_PARAMETERS[k]["recorded"]: + ms_obj_id = self.create_measurement_series( + mp_obj_id, k, SWMM_SUMMARY_PARAMETERS[k]["dimension"] + ) + time = (simulation_start_date + delta).isoformat() + self.create_measurement_result( + ms_obj_id, + SWMM_SUMMARY_PARAMETERS[k]["tww_measurement_type"], + measuring_duration, + time, + ws[k], + ) + return + + def populate_attribute(self, data, table_name, attribute_name, swmm_attribute): + """ + Update an attribute of a tww_od table according to a swmm result + + Parameters: + data (array): data extracted from the node summary + table_name (string): name of the destination table + attribute_name (string): name of the destination attribute + swmm_attribute (string): name of the swmm attribute (ie. maximum_hgl, max_over_full_flow) + """ + + ndata = len(data) + cur = self.con.cursor() + # Loop over each line of the node summary + counter = 0 + for ws in data: + counter += 1 + bf_level = ws[swmm_attribute] + obj_id = ws["id"] + sql = """ + UPDATE tww_od.{table_name} + SET {attribute_name} = {bf_level} + WHERE obj_id = '{obj_id}' + RETURNING obj_id; + """.format( + table_name=table_name, + attribute_name=attribute_name, + bf_level=bf_level, + obj_id=obj_id, + ) + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", str(psycopg2.ProgrammingError)) + return None, None + res = cur.fetchone() + if res is None: + self.feedback_push( + "info", + """{obj_id} in the output file has no correspondance in tww_od.{table_name}.""".format( + obj_id=obj_id, table_name=table_name + ), + ) + self.feedback_set_progress(counter / ndata) + self.con.commit() + + return + + def create_measuring_point_node(self, node_obj_id, sim_description): + """ + For a node creates a measuring point or get its id. + + Parameters: + node_obj_id (string): wastewater node object ID + sim_description (string): name of the simulation + + Returns: + me_obj_id: measuring point object ID + + """ + + # Connects to service and get data and attributes from tableName + cur = self.con.cursor() + + # Test if the measuring point exists + sql = """ + SELECT mp.obj_id + FROM tww_od.measuring_point mp + JOIN tww_od.wastewater_structure ws on mp.fk_wastewater_structure = ws.obj_id + WHERE ws.fk_main_wastewater_node = '{node_obj_id}' + AND mp.remark = '{sim_description}' + """.format( + sim_description=sim_description, node_obj_id=node_obj_id + ) + cur.execute(sql) + res = cur.fetchone() + + if res is None: + # Measuring point doesnt exists, must be created + # 4594 = technical purpose [TO VALIDATE] + sql = """ + INSERT INTO tww_od.measuring_point + (damming_device, identifier, kind, + purpose, remark, fk_wastewater_structure) + SELECT 5721, NULL, '{MEASURING_POINT_KIND}', 4594, + '{sim_description}', ws.obj_id + FROM tww_od.wastewater_structure ws + WHERE fk_main_wastewater_node = '{node_obj_id}' + RETURNING obj_id + """.format( + MEASURING_POINT_KIND=MEASURING_POINT_KIND, + node_obj_id=node_obj_id, + sim_description=sim_description, + ) + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", str(psycopg2.ProgrammingError)) + return None, None + res = cur.fetchone() + if res is None: + mp_obj_id = None + else: + mp_obj_id = res[0] + self.con.commit() + del cur + else: + mp_obj_id = res[0] + return mp_obj_id + + def create_measuring_point_link(self, reach_obj_id, sim_description): + """ + For a node creates a measuring point or get its id. + + Parameters: + reach_obj_id (string): reach object ID + sim_description (string): name of the simulation + + Returns: + me_obj_id: measuring point object ID + + """ + + # Connects to service and get data and attributes from tableName + cur = self.con.cursor() + + # Test if the measuring point exists + sql = """ + SELECT mp.obj_id + FROM tww_od.measuring_point mp + JOIN tww_od.wastewater_networkelement ne ON + ne.fk_wastewater_structure = mp.fk_wastewater_structure + WHERE ne.obj_id = '{reach_obj_id}' + AND mp.remark = '{sim_description}' + """.format( + sim_description=sim_description, reach_obj_id=reach_obj_id + ) + cur.execute(sql) + res = cur.fetchone() + + if res is None: + # Measuring point doesnt exists, must be created + # 4594 = technical purpose [TO VALIDATE] + sql = """ + INSERT INTO tww_od.measuring_point + (damming_device, identifier, kind, purpose, remark, + fk_wastewater_structure) + SELECT 5721, NULL, '{MEASURING_POINT_KIND}', 4594, + '{sim_description}', ne.fk_wastewater_structure + FROM tww_od.wastewater_networkelement ne + WHERE ne.obj_id = '{reach_obj_id}' + RETURNING obj_id + """.format( + MEASURING_POINT_KIND=MEASURING_POINT_KIND, + sim_description=sim_description, + reach_obj_id=reach_obj_id, + ) + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", str(psycopg2.ProgrammingError)) + return None + res = cur.fetchone() + mp_obj_id = res[0] + self.con.commit() + del cur + else: + mp_obj_id = res[0] + return mp_obj_id + + def create_measuring_device(self, mp_obj_id): + """ + For a measuring point creates a measuring device or get its id. + + Parameters: + mp_obj_id (string): measuring point object ID + + Returns: + md_obj_id: measuring device object ID + + """ + + cur = self.con.cursor() + + # Test if the measuring device exists + sql = """ + SELECT md.obj_id + FROM tww_od.measuring_device md + WHERE md.fk_measuring_point = '{mp_obj_id}' + AND remark = '{MEASURING_DEVICE_REMARK}' + """.format( + MEASURING_DEVICE_REMARK=MEASURING_DEVICE_REMARK, mp_obj_id=mp_obj_id + ) + cur.execute(sql) + res = cur.fetchone() + + if res is None: + # Measuring device doesnt exists, must be created + sql = """ + INSERT INTO tww_od.measuring_device + (kind, remark, fk_measuring_point) + VALUES + (5702, '{MEASURING_DEVICE_REMARK}','{mp_obj_id}') + RETURNING obj_id + """.format( + MEASURING_DEVICE_REMARK=MEASURING_DEVICE_REMARK, mp_obj_id=mp_obj_id + ) + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", str(psycopg2.ProgrammingError)) + return None, None + res = cur.fetchone() + if res is None: + mp_obj_id = None + else: + mp_obj_id = res[0] + self.con.commit() + del cur + else: + mp_obj_id = res[0] + return mp_obj_id + + def create_measurement_series(self, mp_obj_id, parameter_name, parameter_dimension): + """ + Creates a measurement serie or get its id. + + Parameters: + mp_obj_id (string): measurement point object ID + parameter_name (string): name of the parameter + parameter_dimension (string): dimension of the parameter + + Returns: + mp_obj_id: measuring point object ID + + """ + + # Connects to service + cur = self.con.cursor() + + # Test if the measurement serie exists + sql = """ + SELECT obj_id FROM tww_od.measurement_series + WHERE remark = '{parameter_name}' + AND fk_measuring_point = '{mp_obj_id}' + """.format( + parameter_name=parameter_name, mp_obj_id=mp_obj_id + ) + cur.execute(sql) + res = cur.fetchone() + + if res is None: + # Measuring point doesnt exists, must be created + # 3217 = other [TO VALIDATE] + # No dimension, else we would need to create four measurements + # series l/s m/s m - [TO VALIDATE] + sql = """ + INSERT INTO tww_od.measurement_series + (identifier, dimension, kind, remark, fk_measuring_point) + VALUES + (null, '{parameter_dimension}', 3217, + '{parameter_name}', '{mp_obj_id}') + RETURNING obj_id + """.format( + parameter_dimension=parameter_dimension, + parameter_name=parameter_name, + mp_obj_id=mp_obj_id, + ) + + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", str(psycopg2.ProgrammingError)) + return None + ms_obj_id = cur.fetchone()[0] + self.con.commit() + else: + ms_obj_id = res[0] + del cur + return ms_obj_id + + def create_measurement_result( + self, ms_obj_id, measurement_type, measuring_duration, time, value + ): + """ + Creates a measurement result or update it. + + Parameters: + ms_obj_id (string): measurement serie object ID + measurement_type (integer): type of measurement 5733=flow, 5734=level, 5732=other + measuring_duration (integer): Time step of the simulation in seconds + time (string): timestamp of the recorded result + value (float): value of the measurement + + Returns: + mr_obj_id: measurement result object ID + + """ + + # Connects to service + cur = self.con.cursor() + + # Test if the measurement result exists (same measurement serie, same time, same type) + sql = """ + SELECT obj_id FROM tww_od.measurement_result + WHERE fk_measurement_series = '{ms_obj_id}' + AND time = '{time}' + AND measurement_type = {measurement_type} + """.format( + ms_obj_id=ms_obj_id, time=time, measurement_type=measurement_type + ) + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", (str(psycopg2.ProgrammingError))) + return None + res = cur.fetchone() + + if res is None: + # Measurement result doesnt exists, must be created + + sql = """ + INSERT INTO tww_od.measurement_result + (identifier, measurement_type, measuring_duration, + time, value, fk_measurement_series) + VALUES + (null, {measurement_type}, {measuring_duration}, '{time}', {value}, '{ms_obj_id}') + RETURNING obj_id + """.format( + measurement_type=measurement_type, + measuring_duration=measuring_duration, + time=time, + value=value, + ms_obj_id=ms_obj_id, + ) + + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", (str(psycopg2.ProgrammingError))) + return None + mr_obj_id = cur.fetchone()[0] + self.con.commit() + else: + mr_obj_id = res[0] + # Measurement result exists, must be updated + sql = """ + UPDATE tww_od.measurement_result + SET measuring_duration={measuring_duration}, value={value} + WHERE obj_id = '{mr_obj_id}' + RETURNING obj_id + """.format( + measuring_duration=measuring_duration, value=value, mr_obj_id=mr_obj_id + ) + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", (str(psycopg2.ProgrammingError))) + return None + mr_obj_id = cur.fetchone()[0] + self.con.commit() + del cur + return mr_obj_id + + def disable_reach_trigger(self): + """ + Disable triggers on the table tww_od.reach + """ + + cur = self.con.cursor() + + # Set value for tww_od.reach.default_coefficient_friction where reach_material is known + sql = """ + ALTER TABLE tww_od.reach DISABLE TRIGGER ALL; + """ + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", (str(psycopg2.ProgrammingError))) + return None + self.con.commit() + del cur + return + + def enable_reach_trigger(self): + """ + Enable triggers on the table tww_od.reach + """ + + cur = self.con.cursor() + + # Set value for tww_od.reach.default_coefficient_friction where reach_material is known + sql = """ + ALTER TABLE tww_od.reach ENABLE TRIGGER ALL; + """ + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", (str(psycopg2.ProgrammingError))) + return None + self.con.commit() + del cur + return + + def set_reach_default_friction(self): + """ + Set default friction in tww_od.reach where default friction is not set + """ + + cur = self.con.cursor() + + # Set value for tww_od.reach.default_coefficient_friction where reach_material is known + sql = """ + UPDATE tww_od.reach r + SET swmm_default_coefficient_of_friction = f.coefficient_of_friction + FROM tww_swmm.reach_coefficient_of_friction f + WHERE r.swmm_default_coefficient_of_friction isnull AND f.fk_material = r.material; + """ + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", (str(psycopg2.ProgrammingError))) + return None + self.con.commit() + del cur + return + + def overwrite_reach_default_friction(self): + """ + Reset default friction in tww_od.reach where default friction + """ + + cur = self.con.cursor() + + # Set value for tww_od.reach.default_coefficient_friction where reach_material is known + sql = """ + UPDATE tww_od.reach r + SET swmm_default_coefficient_of_friction = f.coefficient_of_friction + FROM tww_swmm.reach_coefficient_of_friction f + WHERE f.fk_material = r.material; + """ + try: + cur.execute(sql) + except psycopg2.ProgrammingError: + self.feedback_push("error", f"Error while excecuting: {sql}") + self.feedback_push("error", (str(psycopg2.ProgrammingError))) + return None + self.con.commit() + del cur + return diff --git a/plugin/teksi_wastewater/processing_provider/__init__.py b/plugin/teksi_wastewater/processing_provider/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/plugin/teksi_wastewater/processing_provider/change_reach_direction.py b/plugin/teksi_wastewater/processing_provider/change_reach_direction.py new file mode 100644 index 000000000..f62186b03 --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/change_reach_direction.py @@ -0,0 +1,89 @@ +""" +/*************************************************************************** + TWW processing provider + ------------------- + begin : 18.11.2017 + copyright : (C) 2017 by OPENGIS.ch + email : matthias@opengis.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +from qgis.core import QgsProcessingAlgorithm, QgsProcessingParameterVectorLayer + +from .tww_algorithm import TwwAlgorithm + +__author__ = "Matthias Kuhn & Maxime Trolliet" +__date__ = "2018-08-07" +__copyright__ = "(C) 2018 by OPENGIS.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class ChangeReachDirection(TwwAlgorithm): + """ + Change the direction of the selected reaches + """ + + REACH_LAYER = "REACH_LAYER" + + def name(self): + return "change_direction" + + def displayName(self): + return self.tr("Change reach direction") + + def flags(self): + return super().flags() | QgsProcessingAlgorithm.FlagNoThreading + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + + self.addParameter( + QgsProcessingParameterVectorLayer( + self.REACH_LAYER, + description=self.tr( + "Selected features only - Reach layer, will be modified in place and its direction will be inverted" + ), + ) + ) + + def processAlgorithm(self, parameters, context, feedback): + """Here is where the processing itself takes place.""" + reach_layer = self.parameterAsVectorLayer(parameters, self.REACH_LAYER, context) + + reach_layer.startEditing() + + # feature_count = 0 + + iterator = reach_layer.getSelectedFeatures() + # feature_count = reach_layer.selectedFeatureCount() + + # Loop through relevant reaches + reach_layer.beginEditCommand("change directions") + transaction = reach_layer.dataProvider().transaction() + # if not transaction: + # raise Exception: if there is no transaction, complain to the user! + selected_obj_ids = [feature["obj_id"] for feature in iterator] + transaction.executeSql( + "SELECT tww_od.reach_direction_change('{{{obj_ids}}}');".format( + obj_ids=",".join(selected_obj_ids) + ), + True, + ) + reach_layer.endEditCommand() + feedback.setProgress(100) + + return {} diff --git a/plugin/teksi_wastewater/processing_provider/flow_times.py b/plugin/teksi_wastewater/processing_provider/flow_times.py new file mode 100644 index 000000000..0921cda02 --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/flow_times.py @@ -0,0 +1,214 @@ +""" +/*************************************************************************** + TWW processing provider + ------------------- + begin : 18.11.2017 + copyright : (C) 2017 by OPENGIS.ch + email : matthias@opengis.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +import qgis.utils as qgis_utils +from PyQt5.QtCore import QVariant +from qgis.core import ( + QgsExpression, + QgsFeature, + QgsFeatureRequest, + QgsFeatureSink, + QgsField, + QgsFields, + QgsProcessing, + QgsProcessingAlgorithm, + QgsProcessingContext, + QgsProcessingException, + QgsProcessingFeedback, + QgsProcessingParameterFeatureSink, + QgsProcessingParameterField, + QgsProcessingParameterVectorLayer, + QgsWkbTypes, +) + +from .tww_algorithm import TwwAlgorithm + +__author__ = "Denis Rouzaud" +__date__ = "2018-07-19" +__copyright__ = "(C) 2018 by OPENGIS.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class FlowTimesAlgorithm(TwwAlgorithm): + """""" + + DISTANCE = "DISTANCE" + REACH_LAYER = "REACH_LAYER" + FLOWTIMES_LAYER = "FLOWTIMES_LAYER" + FK_REACH_FIELD = "FK_REACH_FIELD" + FLOWTIMES_FIELD = "FLOWTIMES_FIELD" + OUTPUT = "OUTPUT" + + def name(self): + return "tww_flow_times" + + def displayName(self): + return self.tr("Flow times downstream") + + def flags(self): + return super().flags() | QgsProcessingAlgorithm.FlagNoThreading + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + + # The parameters + description = self.tr("Reach layer") + self.addParameter( + QgsProcessingParameterVectorLayer( + self.REACH_LAYER, + description=description, + types=[QgsProcessing.TypeVectorLine], + ) + ) + description = self.tr("Flow times layer") + self.addParameter( + QgsProcessingParameterVectorLayer( + self.FLOWTIMES_LAYER, + description=description, + types=[QgsProcessing.TypeVector], + ) + ) + description = self.tr("Reach id field") + self.addParameter( + QgsProcessingParameterField( + self.FK_REACH_FIELD, + description=description, + parentLayerParameterName=self.FLOWTIMES_LAYER, + ) + ) + description = self.tr("Flow times field") + self.addParameter( + QgsProcessingParameterField( + self.FLOWTIMES_FIELD, + description=description, + parentLayerParameterName=self.FLOWTIMES_LAYER, + type=QgsProcessingParameterField.Numeric, + ) + ) + + self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr("Flow times"))) + + def processAlgorithm( + self, parameters, context: QgsProcessingContext, feedback: QgsProcessingFeedback + ): + """Here is where the processing itself takes place.""" + + feedback.setProgress(0) + na = qgis_utils.plugins["teksi_wastewater"].network_analyzer + + # init params + reach_layer = self.parameterAsVectorLayer(parameters, self.REACH_LAYER, context) + flow_layer = self.parameterAsVectorLayer(parameters, self.FLOWTIMES_LAYER, context) + fk_reach_field = self.parameterAsFields(parameters, self.FK_REACH_FIELD, context)[0] + flow_time_field = self.parameterAsFields(parameters, self.FLOWTIMES_FIELD, context)[0] + + # create feature sink + fields = QgsFields() + fields.append(QgsField("flow_time", QVariant.Double)) + (sink, dest_id) = self.parameterAsSink( + parameters, + self.OUTPUT, + context, + fields, + QgsWkbTypes.LineString, + reach_layer.sourceCrs(), + ) + if sink is None: + raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT)) + + # get selected reach + iterator = reach_layer.getSelectedFeatures() + feature_count = reach_layer.selectedFeatureCount() + if feature_count != 1: + raise QgsProcessingException(self.invalidSourceError(parameters, self.REACH_LAYER)) + reach_feature = QgsFeature() + iterator.nextFeature(reach_feature) + assert reach_feature.isValid() + tww_reach_obj_id = reach_feature.attribute("obj_id") + + # get top node + reach_features = na.getFeaturesByAttr( + na.getEdgeLayer(), "obj_id", [tww_reach_obj_id] + ).asDict() + assert len(reach_features) > 0 + from_pos = 1 + top_node = None + for fid, reach_feature in reach_features.items(): + if from_pos > reach_feature.attribute("from_pos"): + top_node = reach_feature.attribute("from_obj_id_interpolate") + from_pos = reach_feature.attribute("from_pos") + assert top_node is not None + nodes = na.getFeaturesByAttr(na.getNodeLayer(), "obj_id", [top_node]).asDict() + assert len(nodes) == 1 + top_node_id = next(iter(nodes.values())).id() + + # create graph + _, edges = na.getTree(top_node_id) + feedback.setProgress(50) + cache_edge_features = na.getFeaturesById( + na.getEdgeLayer(), [edge[2]["feature"] for edge in edges] + ).asDict() + + # join and accumulate flow times + i = -1 + flow_time = 0.0 + while True: + i += 1 + feedback.setProgress(50 + i / len(edges) * 50) + if i >= len(edges): + break + + edge = edges[i] + edge_feature = cache_edge_features[edge[2]["feature"]] + # TODO: if top_pos != 1 => merge + if edge_feature.attribute("type") != "reach": + continue + rate = edge_feature.attribute("to_pos") - edge_feature.attribute("from_pos") + assert 0 < rate <= 1 + + expression = QgsExpression( + "{fk_reach} = '{obj_id}'".format( + fk_reach=fk_reach_field, obj_id=edge_feature["obj_id"] + ) + ) + print(expression.expression()) + request = QgsFeatureRequest(expression) + flow_time_feature = next(flow_layer.getFeatures(request)) + + if not flow_time_feature.isValid(): + break + + flow_time += rate * flow_time_feature.attribute(flow_time_field) + + sf = QgsFeature() + sf.setFields(fields) + sf.setAttribute("flow_time", flow_time) + sf.setGeometry(edge_feature.geometry()) + sink.addFeature(sf, QgsFeatureSink.FastInsert) + + # f.setAttributes(attrs) + # sink.addFeature(f, QgsFeatureSink.FastInsert) + # feedback.setProgress(int(current * total)) + + return {self.OUTPUT: dest_id} diff --git a/plugin/teksi_wastewater/processing_provider/provider.py b/plugin/teksi_wastewater/processing_provider/provider.py new file mode 100644 index 000000000..32587094c --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/provider.py @@ -0,0 +1,150 @@ +""" +/*************************************************************************** + TWW processing provider + ------------------- + begin : 18.11.2017 + copyright : (C) 2017 by OPENGIS.ch + email : matthias@opengis.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +import logging +import os + +from processing.core.ProcessingConfig import ProcessingConfig, Setting +from PyQt5.QtGui import QIcon +from qgis.core import Qgis, QgsProcessingProvider +from qgis.utils import iface + +from .change_reach_direction import ChangeReachDirection +from .flow_times import FlowTimesAlgorithm +from .snap_reach import SnapReachAlgorithm +from .sum_up_upstream import SumUpUpstreamAlgorithm +from .swmm_create_input import SwmmCreateInputAlgorithm +from .swmm_execute import SwmmExecuteAlgorithm +from .swmm_extract_results import SwmmExtractResultsAlgorithm +from .swmm_import_results import SwmmImportResultsAlgorithm +from .swmm_set_friction import SwmmSetFrictionAlgorithm + +__author__ = "Matthias Kuhn" +__date__ = "2017-11-18" +__copyright__ = "(C) 2017 by OPENGIS.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + +logger = logging.getLogger(__package__) + + +class TwwProcessingProvider(QgsProcessingProvider): + def __init__(self): + QgsProcessingProvider.__init__(self) + # AlgorithmProvider.__init__(self) + + self.activate = True + + # Load algorithms + self.alglist = [ + SnapReachAlgorithm(), + FlowTimesAlgorithm(), + ChangeReachDirection(), + SumUpUpstreamAlgorithm(), + SwmmCreateInputAlgorithm(), + SwmmExtractResultsAlgorithm(), + SwmmImportResultsAlgorithm(), + SwmmExecuteAlgorithm(), + SwmmSetFrictionAlgorithm(), + ] + try: + from ..interlis.processing_algs.extractlabels_interlis import ( + ExtractlabelsInterlisAlgorithm, + ) + + self.alglist.append(ExtractlabelsInterlisAlgorithm()) + except ImportError: + pass + + for alg in self.alglist: + alg.provider = self + + def getAlgs(self): + algs = [ + SnapReachAlgorithm(), + FlowTimesAlgorithm(), + SumUpUpstreamAlgorithm(), + ChangeReachDirection(), + SwmmCreateInputAlgorithm(), + SwmmExtractResultsAlgorithm(), + SwmmImportResultsAlgorithm(), + SwmmExecuteAlgorithm(), + SwmmSetFrictionAlgorithm(), + ] + try: + from ..interlis.processing_algs.extractlabels_interlis import ( + ExtractlabelsInterlisAlgorithm, + ) + + algs.append(ExtractlabelsInterlisAlgorithm()) + + except ImportError as e: + iface.messageBar().pushMessage( + "Error", + "Could not load tww2ili due to unmet dependencies. See logs for more details.", + level=Qgis.Critical, + ) + logger.error(str(e)) + return algs + + def id(self): + return "tww" + + def name(self): + """This is the name that will appear on the toolbox group. + + It is also used to create the command line name of all the + algorithms from this provider. + """ + return "TWW" + + def icon(self): + return QIcon(self.svgIconPath()) + + def svgIconPath(self): + basepath = os.path.dirname(os.path.abspath(__file__)) + return os.path.join(basepath, "..", "icons", "twwIcon.svg") + + def loadAlgorithms(self): + self.algs = self.getAlgs() + for a in self.algs: + self.addAlgorithm(a) + + def load(self): + ProcessingConfig.settingIcons[self.name()] = self.icon() + ProcessingConfig.addSetting( + Setting( + self.name(), + "SWMM_PATH", + self.tr( + r"SWMM executable (e.g. C:\Program Files (x86)\EPA SWMM 5.1.013\swmm55.exe)" + ), + None, + valuetype=Setting.FILE, + ) + ) + + ProcessingConfig.readSettings() + self.refreshAlgorithms() + return True + + def unload(self): + ProcessingConfig.removeSetting("SWMM_PATH") diff --git a/plugin/teksi_wastewater/processing_provider/snap_reach.py b/plugin/teksi_wastewater/processing_provider/snap_reach.py new file mode 100644 index 000000000..60349fd93 --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/snap_reach.py @@ -0,0 +1,211 @@ +""" +/*************************************************************************** + TWW processing provider + ------------------- + begin : 18.11.2017 + copyright : (C) 2017 by OPENGIS.ch + email : matthias@opengis.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +from qgis.core import ( + QgsExpression, + QgsFeatureRequest, + QgsGeometry, + QgsPointXY, + QgsProcessingParameterBoolean, + QgsProcessingParameterNumber, + QgsProcessingParameterVectorLayer, +) + +from .tww_algorithm import TwwAlgorithm + +__author__ = "Matthias Kuhn" +__date__ = "2017-11-18" +__copyright__ = "(C) 2017 by OPENGIS.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class SnapReachAlgorithm(TwwAlgorithm): + """""" + + DISTANCE = "DISTANCE" + REACH_LAYER = "REACH_LAYER" + WASTEWATER_NODE_LAYER = "WASTEWATER_NODE_LAYER" + ONLY_SELECTED = "ONLY_SELECTED" + + def name(self): + return self.tr("tww_snap_rach") + + def displayName(self): + return self.tr("Snap reach geometry") + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + + # The parameters + self.addParameter( + QgsProcessingParameterNumber( + self.DISTANCE, + type=QgsProcessingParameterNumber.Double, + description=self.tr( + "Maximum snapping distance in meters. Set to 0 for no maximum." + ), + defaultValue=10.0, + ) + ) + self.addParameter( + QgsProcessingParameterBoolean( + self.ONLY_SELECTED, + description=self.tr("Snap only selected reaches."), + defaultValue=True, + ) + ) + self.addParameter( + QgsProcessingParameterVectorLayer( + self.REACH_LAYER, + description=self.tr( + "Reach layer, will be modified in place and used as snapping target" + ), + ) + ) + self.addParameter( + QgsProcessingParameterVectorLayer( + self.WASTEWATER_NODE_LAYER, + description=self.tr("Wastewater node layer, will be used as snapping target"), + ) + ) + + def processAlgorithm(self, parameters, context, feedback): + """Here is where the processing itself takes place.""" + + reach_layer = self.parameterAsVectorLayer(parameters, self.REACH_LAYER, context) + wastewater_node_layer = self.parameterAsVectorLayer( + parameters, self.WASTEWATER_NODE_LAYER, context + ) + distance = self.parameterAsDouble(parameters, self.DISTANCE, context) + only_selected = self.parameterAsBool(parameters, self.ONLY_SELECTED, context) + + reach_layer.startEditing() + + feature_count = 0 + if only_selected: + iterator = reach_layer.getSelectedFeatures() + feature_count = reach_layer.selectedFeatureCount() + else: + iterator = reach_layer.getFeatures() + feature_count = reach_layer.featureCount() + + # Loop through relevant reaches + reach_layer.beginEditCommand("Snap reaches to points") + try: + reaches = list() + current_feature = 0 + for reach in iterator: + reaches.append(reach) + # Batch processing: process blocks of 2000 reaches + if len(reaches) == 2000: + self.processFeatures(reaches, reach_layer, wastewater_node_layer, distance) + reaches = list() + + current_feature += 1 + feedback.setProgress(current_feature * 100.0 / feature_count) + + self.processFeatures(reaches, reach_layer, wastewater_node_layer, distance) + except: # NOQA + reach_layer.destroyEditCommand() + raise + reach_layer.endEditCommand() + feedback.setProgress(100) + + return {} + + def processFeatures(self, reaches, reach_layer, wastewater_node_layer, distance_threshold): + ids = list() + to_ids = list() + # Gather ids of connected networkelements + # to_ids are also gathered separately, because they can be either + # reaches or nodes + for reach in reaches: + if reach["rp_from_fk_wastewater_networkelement"]: + ids.append(reach["rp_from_fk_wastewater_networkelement"]) + + if reach["rp_to_fk_wastewater_networkelement"]: + ids.append(reach["rp_to_fk_wastewater_networkelement"]) + to_ids.append(reach["rp_to_fk_wastewater_networkelement"]) + + # Get all nodes on which to snap + quoted_ids = [QgsExpression.quotedValue(objid) for objid in ids] + node_request = QgsFeatureRequest() + filter_expression = '"obj_id" IN ({ids})'.format(ids=",".join(quoted_ids)) + node_request.setFilterExpression(filter_expression) + node_request.setSubsetOfAttributes([]) + + nodes = dict() + for node in wastewater_node_layer.getFeatures(node_request): + nodes[node["obj_id"]] = node + + # Get all reaches on which to snap + quoted_to_ids = [QgsExpression.quotedValue(objid) for objid in to_ids] + reach_request = QgsFeatureRequest() + filter_expression = '"obj_id" IN ({ids})'.format(ids=",".join(quoted_to_ids)) + reach_request.setFilterExpression(filter_expression) + reach_request.setSubsetOfAttributes([]) + + target_reaches = dict() + for target_reach in reach_layer.getFeatures(reach_request): + target_reaches[target_reach["obj_id"]] = target_reach + + for reach in reaches: + reach_geometry = QgsGeometry(reach.geometry()) + from_id = reach["rp_from_fk_wastewater_networkelement"] + if from_id in list(nodes.keys()): + if ( + distance_threshold == 0 + or reach_geometry.sqrDistToVertexAt(nodes[from_id].geometry().asPoint(), 0) + < distance_threshold + ): + reach_geometry.moveVertex(nodes[from_id].geometry().constGet(), 0) + + to_id = reach["rp_to_fk_wastewater_networkelement"] + if to_id in list(nodes.keys()): + last_vertex = reach_geometry.constGet().nCoordinates() - 1 + if ( + distance_threshold == 0 + or reach_geometry.sqrDistToVertexAt( + nodes[to_id].geometry().asPoint(), last_vertex + ) + < distance_threshold + ): + reach_geometry.moveVertex(nodes[to_id].geometry().constGet(), last_vertex) + + if to_id in list(target_reaches.keys()): + last_vertex = reach_geometry.constGet().nCoordinates() - 1 + target_reach = target_reaches[to_id] + ( + distance, + point, + min_distance_point, + after_vertex, + ) = target_reach.geometry().closestSegmentWithContext( + QgsPointXY(reach_geometry.vertexAt(last_vertex)) + ) + if distance_threshold == 0 or distance < distance_threshold: + reach_geometry.moveVertex(point.x(), point.y(), last_vertex) + + reach.setGeometry(reach_geometry) + reach_layer.updateFeature(reach) diff --git a/plugin/teksi_wastewater/processing_provider/sum_up_upstream.py b/plugin/teksi_wastewater/processing_provider/sum_up_upstream.py new file mode 100644 index 000000000..c9e0b728c --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/sum_up_upstream.py @@ -0,0 +1,448 @@ +""" +/*************************************************************************** + TWW processing provider + ------------------- + begin : 18.11.2017 + copyright : (C) 2017 by OPENGIS.ch + email : matthias@opengis.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + + +import statistics + +from PyQt5.QtCore import QVariant +from qgis.core import ( + NULL, + QgsExpression, + QgsExpressionContext, + QgsExpressionContextUtils, + QgsFeature, + QgsFeatureRequest, + QgsFeatureSink, + QgsField, + QgsGeometry, + QgsProcessing, + QgsProcessingContext, + QgsProcessingException, + QgsProcessingFeedback, + QgsProcessingParameterBoolean, + QgsProcessingParameterDefinition, + QgsProcessingParameterEnum, + QgsProcessingParameterExpression, + QgsProcessingParameterFeatureSink, + QgsProcessingParameterField, + QgsProcessingParameterVectorLayer, + QgsWkbTypes, +) + +from .tww_algorithm import TwwAlgorithm + +__author__ = "Matthias Kuhn" +__date__ = "2019-04-09" +__copyright__ = "(C) 2018 by OPENGIS.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class Reach: + def __init__(self, from_id, to_id, value, geometry): + self.from_id = from_id + self.to_id = to_id + self.value = value + self.geometry = geometry + + +class SumUpUpstreamAlgorithm(TwwAlgorithm): + """""" + + REACH_LAYER = "REACH_LAYER" + WASTEWATER_NODE_LAYER = "WASTEWATER_NODE_LAYER" + VALUE_EXPRESSION = "VALUE_EXPRESSION" + REACH_PK_NAME = "REACH_PK_NAME" + NODE_PK_NAME = "NODE_PK_NAME" + NODE_FROM_FK_NAME = "NODE_FROM_FK_NAME" + NODE_TO_FK_NAME = "NODE_TO_FK_NAME" + BRANCH_BEHAVIOR = "BRANCH_BEHAVIOR" + CREATE_LOOP_LAYER = "CREATE_LOOP_LAYER" + + OUTPUT = "OUTPUT" + LOOP_OUTPUT = "LOOP_OUTPUT" + + def name(self): + return "tww_values_upstream" + + def displayName(self): + return self.tr("Sum up upstream") + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + + # The parameters + description = self.tr( + 'Source value expression. Use COALESCE("field_name", 0) to treat NULL values as 0.' + ) + self.addParameter( + QgsProcessingParameterExpression( + self.VALUE_EXPRESSION, + description=description, + parentLayerParameterName=self.REACH_LAYER, + ) + ) + description = self.tr("Branch behavior") + self.addParameter( + QgsProcessingParameterEnum( + self.BRANCH_BEHAVIOR, + description=description, + options=[self.tr("Minimum"), self.tr("Maximum"), self.tr("Average")], + ) + ) + + self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr("Summed up"))) + + description = self.tr("Create a layer with nodes in loops") + self.addAdvancedParameter( + QgsProcessingParameterBoolean( + self.CREATE_LOOP_LAYER, description=description, defaultValue=False + ) + ) + + self.addAdvancedParameter( + QgsProcessingParameterFeatureSink( + self.LOOP_OUTPUT, + self.tr( + 'Loop nodes (Only created if "Crate a layer with nodes in loops" option is activated)' + ), + optional=True, + ) + ) + description = self.tr("Reach Layer") + self.addAdvancedParameter( + QgsProcessingParameterVectorLayer( + self.REACH_LAYER, + description=description, + types=[QgsProcessing.TypeVectorLine], + defaultValue="vw_tww_reach", + ) + ) + description = self.tr("Wastewater Node Layer") + self.addAdvancedParameter( + QgsProcessingParameterVectorLayer( + self.WASTEWATER_NODE_LAYER, + description=description, + types=[QgsProcessing.TypeVector], + defaultValue="vw_wastewater_node", + ) + ) + + description = self.tr("Primary Key Field Reach") + self.addAdvancedParameter( + QgsProcessingParameterField( + self.REACH_PK_NAME, + description=description, + parentLayerParameterName=self.REACH_LAYER, + defaultValue="obj_id", + ) + ) + + description = self.tr("Primary Key Field Node") + self.addAdvancedParameter( + QgsProcessingParameterField( + self.NODE_PK_NAME, + description=description, + parentLayerParameterName=self.WASTEWATER_NODE_LAYER, + defaultValue="obj_id", + ) + ) + + description = self.tr("Foreign Key Field From") + self.addAdvancedParameter( + QgsProcessingParameterField( + self.NODE_FROM_FK_NAME, + description=description, + parentLayerParameterName=self.REACH_LAYER, + defaultValue="rp_from_fk_wastewater_networkelement", + ) + ) + + description = self.tr("Foreign Key Field To") + self.addAdvancedParameter( + QgsProcessingParameterField( + self.NODE_TO_FK_NAME, + description=description, + parentLayerParameterName=self.REACH_LAYER, + defaultValue="rp_to_fk_wastewater_networkelement", + ) + ) + + def addAdvancedParameter(self, parameter): + parameter.setFlags(parameter.flags() | QgsProcessingParameterDefinition.FlagAdvanced) + self.addParameter(parameter) + + def processAlgorithm( + self, parameters, context: QgsProcessingContext, feedback: QgsProcessingFeedback + ): + """Here is where the processing itself takes place.""" + + feedback.setProgress(0) + + # init params + reach_layer = self.parameterAsVectorLayer(parameters, self.REACH_LAYER, context) + wastewater_node_layer = self.parameterAsVectorLayer( + parameters, self.WASTEWATER_NODE_LAYER, context + ) + value_expression = self.parameterAsExpression(parameters, self.VALUE_EXPRESSION, context) + reach_pk_name = self.parameterAsFields(parameters, self.REACH_PK_NAME, context)[0] + node_pk_name = self.parameterAsFields(parameters, self.NODE_PK_NAME, context)[0] + node_from_fk_name = self.parameterAsFields(parameters, self.NODE_FROM_FK_NAME, context)[0] + node_to_fk_name = self.parameterAsFields(parameters, self.NODE_TO_FK_NAME, context)[0] + branch_behavior = self.parameterAsEnum(parameters, self.BRANCH_BEHAVIOR, context) + create_loop_layer = self.parameterAsBool(parameters, self.CREATE_LOOP_LAYER, context) + + if branch_behavior == 0: + aggregate_method = self.aggregate_method_min + elif branch_behavior == 1: + aggregate_method = self.aggregate_method_max + elif branch_behavior == 2: + aggregate_method = self.aggregate_method_mean + else: + aggregate_method = self.aggregate_method_not_implemented + + # create feature sink + fields = wastewater_node_layer.fields() + fields.append(QgsField("value", QVariant.Double)) + (sink, dest_id) = self.parameterAsSink( + parameters, + self.OUTPUT, + context, + fields, + QgsWkbTypes.Point, + reach_layer.sourceCrs(), + ) + + loop_sink = None + loop_dest_id = None + if create_loop_layer: + (loop_sink, loop_dest_id) = self.parameterAsSink( + parameters, + self.LOOP_OUTPUT, + context, + fields, + QgsWkbTypes.Point, + reach_layer.sourceCrs(), + ) + + if sink is None: + raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT)) + + feature_count = reach_layer.featureCount() + + reaches_by_from_node = dict() + reaches_by_id = dict() + + expression = QgsExpression(value_expression) + context = QgsExpressionContext( + QgsExpressionContextUtils.globalProjectLayerScopes(reach_layer) + ) + expression.prepare(context) + + progress = 0 + feedback.setProgressText(self.tr("Indexing reaches")) + for reach in reach_layer.getFeatures(QgsFeatureRequest()): + if reach[node_from_fk_name] == NULL: + continue + + context.setFeature(reach) + value = expression.evaluate(context) + reach_obj = Reach( + reach[node_from_fk_name], + reach[node_to_fk_name], + value, + reach.geometry(), + ) + reaches_by_from_node.setdefault(reach_obj.from_id, []).append(reach_obj) + reaches_by_id[reach[reach_pk_name]] = reach_obj + + feedback.setProgress(progress / feature_count * 10) + progress += 1 + + loop_nodes = [] + current_feature = 0 + calculated_values = {} + + feedback.setProgressText(self.tr("Analyzing network")) + for node in wastewater_node_layer.getFeatures(): + from_node_id = node[node_pk_name] + + processed_nodes = [] + times = [] + if from_node_id in reaches_by_from_node.keys(): + for reach in reaches_by_from_node[from_node_id]: + times.append( + self.calculate_branch( + reach, + reaches_by_from_node, + reaches_by_id, + list(processed_nodes), + calculated_values, + aggregate_method, + loop_nodes, + feedback, + ) + ) + + if times: + time = aggregate_method(times, feedback) + else: + time = 0 + + current_feature += 1 + + calculated_values[node[node_pk_name]] = time + new_node = QgsFeature(node) + new_node.setFields(fields) + new_node.setAttributes(node.attributes() + [time]) + + sink.addFeature(new_node, QgsFeatureSink.FastInsert) + + if create_loop_layer and from_node_id in loop_nodes: + loop_sink.addFeature(node, QgsFeatureSink.FastInsert) + + feedback.setProgress(10 + current_feature / feature_count * 90) + + result = {self.OUTPUT: dest_id} + if create_loop_layer: + result[self.LOOP_OUTPUT] = loop_dest_id + + return result + + def process_node( + self, + node_id, + previous_reach, + reaches_by_from_node, + reaches_by_id, + processed_nodes, + calculated_values, + aggregate_method, + loop_nodes, + feedback, + ): + time = 0 + + while node_id in reaches_by_from_node.keys() or node_id in reaches_by_id.keys(): + if node_id in calculated_values: + return calculated_values[node_id] + time + if node_id in processed_nodes: + # feedback.reportError(self.tr('Loop at node: {}'.format(node_id))) + loop_nodes.append(node_id) + return 0 + + processed_nodes.append(node_id) + + if feedback.isCanceled(): + return NULL + + if node_id not in reaches_by_from_node: + # Blind connection: add proportionally + reach = reaches_by_id[node_id] + offset = reach.geometry.lineLocatePoint( + QgsGeometry(previous_reach.geometry.constGet().endPoint()) + ) + length = reach.geometry.length() + remaining_part = 1 - offset / length + # feedback.pushInfo('Length: {} Offset: {} Part: {}'.format(length, offset, remaining_part, reach.value * remaining_part)) + time += reach.value * remaining_part + node_id = reach.to_id + else: + current_reaches = reaches_by_from_node[node_id] + if len(current_reaches) == 1: + # In case there is just one downstream reach, calculate in here + # Starting a recursive approach results in a maximum call stack exception + time += current_reaches[0].value + node_id = current_reaches[0].to_id + previous_reach = current_reaches[0] + else: + # Branching occurred: calculate every possible path and aggregate all values + times = [] + for reach in current_reaches: + times.append( + self.calculate_branch( + reach, + reaches_by_from_node, + reaches_by_id, + list(processed_nodes), + calculated_values, + aggregate_method, + loop_nodes, + feedback, + ) + ) + + if times: + time += aggregate_method(times, feedback) + + return time + + return time + + def calculate_branch( + self, + reach, + reaches_by_from_node, + reaches_by_id, + processed_nodes, + calculated_values, + aggregate_method, + loop_nodes, + feedback, + ): + return reach.value + self.process_node( + reach.to_id, + reach, + reaches_by_from_node, + reaches_by_id, + processed_nodes, + calculated_values, + aggregate_method, + loop_nodes, + feedback, + ) + + @staticmethod + def aggregate_method_min(values, feedback=QgsProcessingFeedback()): + if values: + return min(values) + + return 0 + + @staticmethod + def aggregate_method_max(values, feedback=QgsProcessingFeedback()): + if values: + return max(values) + + return 0 + + @staticmethod + def aggregate_method_mean(values, feedback=QgsProcessingFeedback()): + if values: + return statistics.mean(values) + + return 0 + + @staticmethod + def aggregate_method_not_implemented(values, feedback=QgsProcessingFeedback()): + feedback.pushError("Aggregate method not implemented") diff --git a/plugin/teksi_wastewater/processing_provider/swmm_create_input.py b/plugin/teksi_wastewater/processing_provider/swmm_create_input.py new file mode 100644 index 000000000..d04428171 --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/swmm_create_input.py @@ -0,0 +1,179 @@ +""" +/*************************************************************************** + TWW-swmm processing provider + ------------------- + begin : 07.2019 + copyright : (C) 2019 by ig-group.ch + email : timothee.produit@ig-group.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + + +import datetime + +from qgis.core import ( + QgsProcessingContext, + QgsProcessingFeedback, + QgsProcessingParameterBoolean, + QgsProcessingParameterEnum, + QgsProcessingParameterFile, + QgsProcessingParameterFileDestination, + QgsProcessingParameterString, + QgsProject, +) + +from .tww_algorithm import TwwAlgorithm +from .TwwSwmm import TwwSwmm + +__author__ = "Timothée Produit" +__date__ = "2019-08-01" +__copyright__ = "(C) 2019 by IG-Group.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class SwmmCreateInputAlgorithm(TwwAlgorithm): + """""" + + DATABASE = "DATABASE" + TEMPLATE_INP_FILE = "TEMPLATE_INP_FILE" + INP_FILE = "INP_FILE" + STATE = "STATE" + ONLY_SELECTED = "ONLY_SELECTED" + + def name(self): + return "swmm_create_input" + + def displayName(self): + return self.tr("SWMM Create Input") + + def shortHelpString(self): + return self.tr( + """ + This tool will export the entire PRIMARY network as an input file for SWMM. + If \"Export only selected network\" is selected, the entire selected network is exported, including the secondary network. + Note that at this stage of the development, export of special structures (pumps, weirs, dividers) and related curves must be checked. + Advices to improve the export can be submited as github issues. + See: https://qgep.github.io/docs/tww_swmm/Create-Input.html # TODO should point to new url // skip-keyword-check + """ + ) + + def helpUrl(self): + return "https://qgep.github.io/docs/tww_swmm/Create-Input.html" # TODO should point to new url // skip-keyword-check + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + self.stateOptions = ["current", "planned"] + # The parameters + description = self.tr("Database") + self.addParameter( + QgsProcessingParameterString( + self.DATABASE, description=description, defaultValue="pg_tww" + ) + ) + + description = self.tr("State (current or planned)") + self.addParameter( + QgsProcessingParameterEnum( + self.STATE, + description=description, + options=self.stateOptions, + defaultValue=self.stateOptions[0], + ) + ) + + description = self.tr("Template INP File") + self.addParameter( + QgsProcessingParameterFile( + self.TEMPLATE_INP_FILE, description=description, extension="inp" + ) + ) + + description = self.tr("Destination INP File") + self.addParameter( + QgsProcessingParameterFileDestination( + self.INP_FILE, description=description, fileFilter="inp (*.inp)" + ) + ) + + description = self.tr( + "Export only selected network (including the secondary network if selected)" + ) + self.addParameter( + QgsProcessingParameterBoolean( + self.ONLY_SELECTED, description=description, defaultValue=False + ) + ) + + def processAlgorithm( + self, parameters, context: QgsProcessingContext, feedback: QgsProcessingFeedback + ): + """Here is where the processing itself takes place.""" + + feedback.setProgress(0) + + # init params + database = self.parameterAsString(parameters, self.DATABASE, context) + state = self.parameterAsString(parameters, self.STATE, context) + template_inp_file = self.parameterAsFile(parameters, self.TEMPLATE_INP_FILE, context) + inp_file = self.parameterAsFileOutput(parameters, self.INP_FILE, context) + state = self.stateOptions[int(state)] + if state not in ["current", "planned"]: + feedback.reportError( + 'State must be "planned" or "current", state was set to "current"' + ) + state = "current" + only_selected = self.parameterAsBoolean(parameters, self.ONLY_SELECTED, context) + + # Get selection + if only_selected: + hierarchy = None + structures_layers = QgsProject.instance().mapLayersByName( + "vw_tww_wastewater_structure" + ) + if structures_layers: + structures = structures_layers[0].selectedFeatures() + selected_structures = [] + for struct in structures: + selected_structures.append(str(struct["wn_obj_id"])) + else: + self.structures = [] + + reaches_layers = QgsProject.instance().mapLayersByName("vw_tww_reach") + if reaches_layers: + reaches = reaches_layers[0].selectedFeatures() + selected_reaches = [] + for reach in reaches: + selected_reaches.append(str(reach["obj_id"])) + else: + hierarchy = "primary" + selected_structures = None + selected_reaches = None + # Connect to TWW database and perform translation + with TwwSwmm( + datetime.datetime.today().isoformat(), + database, + state, + inp_file, + template_inp_file, + None, + None, + feedback, + ) as qs: + qs.write_input(hierarchy, selected_structures, selected_reaches) + feedback.setProgress(100) + + return {self.INP_FILE: inp_file} diff --git a/plugin/teksi_wastewater/processing_provider/swmm_execute.py b/plugin/teksi_wastewater/processing_provider/swmm_execute.py new file mode 100644 index 000000000..014dfc8f1 --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/swmm_execute.py @@ -0,0 +1,117 @@ +""" +/*************************************************************************** + TWW-swmm processing provider + ------------------- + begin : 07.2019 + copyright : (C) 2019 by ig-group.ch + email : timothee.produit@ig-group.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +import os +import re + +from processing.core.ProcessingConfig import ProcessingConfig +from qgis.core import ( + QgsProcessingContext, + QgsProcessingException, + QgsProcessingFeedback, + QgsProcessingParameterFile, + QgsProcessingParameterFileDestination, +) + +from .tww_algorithm import TwwAlgorithm +from .TwwSwmm import TwwSwmm + +__author__ = "Timothée Produit" +__date__ = "2019-08-01" +__copyright__ = "(C) 2019 by IG-Group.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class SwmmExecuteAlgorithm(TwwAlgorithm): + """""" + + INP_FILE = "INP_FILE" + RPT_FILE = "RPT_FILE" + + def name(self): + return "swmm_execute" + + def displayName(self): + return self.tr("SWMM Execute") + + def shortHelpString(self): + return self.tr( + """ + Launch a swmm simulation. + Note that usually a .inp file exported with TWW is not directly launchable. It must be checked and edited with a SWMM interface. + See: https://qgep.github.io/docs/tww_swmm/Execute.html # TODO should point to new url // skip-keyword-check + """ + ) + + def helpUrl(self): + return "https://qgep.github.io/docs/tww_swmm/Execute.html" # TODO should point to new url // skip-keyword-check + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + + # The parameters + description = self.tr("INP File") + self.addParameter( + QgsProcessingParameterFile(self.INP_FILE, description=description, extension="inp") + ) + + description = self.tr("RPT File") + self.addParameter( + QgsProcessingParameterFileDestination( + self.RPT_FILE, description=description, fileFilter="rpt (*.rpt)" + ) + ) + + def processAlgorithm( + self, parameters, context: QgsProcessingContext, feedback: QgsProcessingFeedback + ): + """Here is where the processing itself takes place.""" + + # init params + rpt_file = self.parameterAsFile(parameters, self.RPT_FILE, context) + inp_file = self.parameterAsFileOutput(parameters, self.INP_FILE, context) + swmm_cli = os.path.abspath(ProcessingConfig.getSetting("SWMM_PATH")) + if not swmm_cli: + # raise GeoAlgorithmExecutionException( + # 'Swmm command line toom is not configured.\n\ + # Please configure it before running Swmm algorithms.') + raise QgsProcessingException( + self.tr( + "Swmm command line tool is not configured.\n\ + Please configure it before running Swmm algorithms." + ) + ) + + with TwwSwmm(None, None, None, inp_file, None, rpt_file, swmm_cli, feedback) as qs: + prompt = qs.execute_swmm() + + feedback.pushInfo(prompt) + + if re.search("There are errors", prompt): + feedback.reportError(prompt) + feedback.reportError("There were errors, run the file in SWMM GUI for more details") + + feedback.setProgress(100) + + return {} diff --git a/plugin/teksi_wastewater/processing_provider/swmm_extract_results.py b/plugin/teksi_wastewater/processing_provider/swmm_extract_results.py new file mode 100644 index 000000000..d484723ae --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/swmm_extract_results.py @@ -0,0 +1,159 @@ +""" +/*************************************************************************** + TWW-swmm processing provider + ------------------- + begin : 07.2019 + copyright : (C) 2019 by ig-group.ch + email : timothee.produit@ig-group.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +from PyQt5.QtCore import QVariant +from qgis.core import ( + QgsFeature, + QgsFeatureSink, + QgsField, + QgsFields, + QgsProcessingContext, + QgsProcessingException, + QgsProcessingFeedback, + QgsProcessingParameterFeatureSink, + QgsProcessingParameterFile, +) + +from .tww_algorithm import TwwAlgorithm +from .TwwSwmm import TwwSwmm + +__author__ = "Timothée Produit" +__date__ = "2019-08-01" +__copyright__ = "(C) 2019 by IG-Group.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class SwmmExtractResultsAlgorithm(TwwAlgorithm): + """""" + + RPT_FILE = "RPT_FILE" + NODE_SUMMARY = "NODE_SUMMARY" + LINK_SUMMARY = "LINK_SUMMARY" + XSECTION_SUMMARY = "XSECTION_SUMMARY" + + def name(self): + return "swmm_extract_results" + + def displayName(self): + return self.tr("SWMM Extract Results") + + def shortHelpString(self): + return self.tr( + """ + Import SWMM results in QGIS temporary tables. + See: https://qgep.github.io/docs/tww_swmm/Extract-Results.html # TODO should point to new url // skip-keyword-check + """ + ) + + def helpUrl(self): + return "https://qgep.github.io/docs/tww_swmm/Extract-Results.html" # TODO should point to new url // skip-keyword-check + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + + # The parameters + description = self.tr("RPT File") + self.addParameter( + QgsProcessingParameterFile( + self.RPT_FILE, description=description, fileFilter="rpt (*.rpt)" + ) + ) + + self.addParameter( + QgsProcessingParameterFeatureSink(self.NODE_SUMMARY, self.tr("Node summary")) + ) + + self.addParameter( + QgsProcessingParameterFeatureSink(self.LINK_SUMMARY, self.tr("Link summary")) + ) + + def processAlgorithm( + self, parameters, context: QgsProcessingContext, feedback: QgsProcessingFeedback + ): + """Here is where the processing itself takes place.""" + + feedback.setProgress(1) + + # init params + rpt_file = self.parameterAsFileOutput(parameters, self.RPT_FILE, context) + + # create feature sink for node summary + fields = QgsFields() + + fields.append(QgsField("id", QVariant.String)) + fields.append(QgsField("type", QVariant.String)) + fields.append(QgsField("average_depth", QVariant.Double)) + fields.append(QgsField("maximum_depth", QVariant.Double)) + fields.append(QgsField("maximum_hgl", QVariant.Double)) + fields.append(QgsField("time_max_day", QVariant.Int)) + fields.append(QgsField("time_max_time", QVariant.String)) + fields.append(QgsField("reported_max_depth", QVariant.Double)) + (sink_node, dest_id) = self.parameterAsSink(parameters, self.NODE_SUMMARY, context, fields) + if sink_node is None: + raise QgsProcessingException(self.invalidSinkError(parameters, self.NODE_SUMMARY)) + + # Get node summary from output file + qs = TwwSwmm(None, None, None, None, None, rpt_file, None, feedback) + node_summary = qs.extract_node_depth_summary() + + # Fill node summary with data + for ns in node_summary: + sf = QgsFeature() + sf.setFields(fields) + for k in ns.keys(): + index = fields.indexOf(k) + if index != -1: + sf.setAttribute(k, ns[k]) + sink_node.addFeature(sf, QgsFeatureSink.FastInsert) + feedback.setProgress(50) + + # create feature sink for link summary + fields = QgsFields() + fields.append(QgsField("id", QVariant.String)) + fields.append(QgsField("type", QVariant.String)) + fields.append(QgsField("maximum_flow", QVariant.Double)) + fields.append(QgsField("time_max_day", QVariant.Int)) + fields.append(QgsField("time_max_time", QVariant.String)) + fields.append(QgsField("maximum_velocity", QVariant.Double)) + fields.append(QgsField("max_over_full_flow", QVariant.Double)) + fields.append(QgsField("max_over_full_depth", QVariant.Double)) + (sink_link, dest_id) = self.parameterAsSink(parameters, self.LINK_SUMMARY, context, fields) + if sink_link is None: + raise QgsProcessingException(self.invalidSinkError(parameters, self.LINK_SUMMARY)) + + # Get link summary from output file + link_summary = qs.extract_link_flow_summary() + + # Fill node summary with data + for ns in link_summary: + sf = QgsFeature() + sf.setFields(fields) + for k in ns.keys(): + index = fields.indexOf(k) + if index != -1: + sf.setAttribute(k, ns[k]) + sink_link.addFeature(sf, QgsFeatureSink.FastInsert) + feedback.setProgress(100) + + return {self.NODE_SUMMARY: sink_node, self.LINK_SUMMARY: sink_link} diff --git a/plugin/teksi_wastewater/processing_provider/swmm_import_results.py b/plugin/teksi_wastewater/processing_provider/swmm_import_results.py new file mode 100644 index 000000000..8d7f9b5eb --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/swmm_import_results.py @@ -0,0 +1,161 @@ +""" +/*************************************************************************** + TWW-swmm processing provider + ------------------- + begin : 07.2019 + copyright : (C) 2019 by ig-group.ch + email : timothee.produit@ig-group.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +from qgis.core import ( + QgsProcessingContext, + QgsProcessingFeedback, + QgsProcessingParameterBoolean, + QgsProcessingParameterFile, + QgsProcessingParameterString, +) + +from .tww_algorithm import TwwAlgorithm +from .TwwSwmm import TwwSwmm + +__author__ = "Timothée Produit" +__date__ = "2021-04-30" +__copyright__ = "(C) 2021 by map.ig-group.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class SwmmImportResultsAlgorithm(TwwAlgorithm): + """""" + + RPT_FILE = "RPT_FILE" + DATABASE = "DATABASE" + SIM_DESCRIPTION = "SIM_DESCRIPTION" + IMPORT_SUMMARY = "IMPORT_SUMMARY" + IMPORT_FULL_RESULTS = "IMPORT_FULL_RESULTS" + POPULATE_BACKFLOW_LEVEL = "POPULATE_BACKFLOW_LEVEL" + POPULATE_HYDRAULIC_LOAD = "POPULATE_HYDRAULIC_LOAD" + + def name(self): + return "swmm_import_results" + + def displayName(self): + return self.tr("SWMM Import Results") + + def shortHelpString(self): + return self.tr( + """ + Import SWMM results in TWW database. + See: https://qgep.github.io/docs/tww_swmm/Extract-Results.html # TODO should point to new url // skip-keyword-check + """ + ) + + def helpUrl(self): + return "https://qgep.github.io/docs/tww_swmm/Import-Results.html" # TODO should point to new url // skip-keyword-check + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + + # The parameters + description = self.tr("SWMM report file (.rpt)") + self.addParameter(QgsProcessingParameterFile(self.RPT_FILE, description=description)) + + description = self.tr("Database") + self.addParameter( + QgsProcessingParameterString( + self.DATABASE, description=description, defaultValue="pg_tww" + ) + ) + + description = self.tr("Simulation name") + self.addParameter( + QgsProcessingParameterString( + self.SIM_DESCRIPTION, + description=description, + defaultValue="SWMM simulation, rain T100, current", + ) + ) + + description = self.tr("Import summary") + self.addParameter( + QgsProcessingParameterBoolean( + self.IMPORT_SUMMARY, description=description, defaultValue=True + ) + ) + + description = self.tr("Import full results") + self.addParameter( + QgsProcessingParameterBoolean( + self.IMPORT_FULL_RESULTS, description=description, defaultValue=False + ) + ) + + description = self.tr("Import Max HGL in tww_od.wastewater_node.backflow_level") + self.addParameter( + QgsProcessingParameterBoolean( + self.POPULATE_BACKFLOW_LEVEL, + description=description, + defaultValue=False, + ) + ) + + description = self.tr( + "Import Max/Full Flow in tww_od.reach.dss2020_hydraulic_load_current" + ) + self.addParameter( + QgsProcessingParameterBoolean( + self.POPULATE_HYDRAULIC_LOAD, + description=description, + defaultValue=False, + ) + ) + + def processAlgorithm( + self, parameters, context: QgsProcessingContext, feedback: QgsProcessingFeedback + ): + """Here is where the processing itself takes place.""" + + feedback.pushInfo("The import started, it can take a few minutes.") + feedback.setProgress(1) + + # init params + rpt_file = self.parameterAsFileOutput(parameters, self.RPT_FILE, context) + database = self.parameterAsString(parameters, self.DATABASE, context) + sim_description = self.parameterAsString(parameters, self.SIM_DESCRIPTION, context) + import_summary = self.parameterAsBoolean(parameters, self.IMPORT_SUMMARY, context) + import_full_result = self.parameterAsBoolean(parameters, self.IMPORT_FULL_RESULTS, context) + import_backflow_level = self.parameterAsBoolean( + parameters, self.POPULATE_BACKFLOW_LEVEL, context + ) + import_hydraulic_load = self.parameterAsBoolean( + parameters, self.POPULATE_HYDRAULIC_LOAD, context + ) + + # Get node summary from output file + with TwwSwmm(sim_description, database, None, None, None, rpt_file, None, feedback) as qs: + if import_summary: + qs.import_summary(sim_description) + if import_full_result: + qs.import_full_results(sim_description) + if import_backflow_level: + qs.import_backflow_level() + if import_hydraulic_load: + qs.import_hydraulic_load() + + feedback.setProgress(100) + + return {} diff --git a/plugin/teksi_wastewater/processing_provider/swmm_set_friction.py b/plugin/teksi_wastewater/processing_provider/swmm_set_friction.py new file mode 100644 index 000000000..b8241a896 --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/swmm_set_friction.py @@ -0,0 +1,105 @@ +""" +/*************************************************************************** + TWW-swmm processing provider + ------------------- + begin : 07.2019 + copyright : (C) 2019 by ig-group.ch + email : timothee.produit@ig-group.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + + +from qgis.core import ( + QgsProcessingContext, + QgsProcessingFeedback, + QgsProcessingParameterBoolean, + QgsProcessingParameterString, +) + +from .tww_algorithm import TwwAlgorithm +from .TwwSwmm import TwwSwmm + +__author__ = "Timothée Produit" +__date__ = "2019-08-01" +__copyright__ = "(C) 2019 by IG-Group.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class SwmmSetFrictionAlgorithm(TwwAlgorithm): + """""" + + DATABASE = "DATABASE" + OVERWRITE_VALUES = "OVERWRITE_VALUES" + + def name(self): + return "swmm_set_friction" + + def displayName(self): + return self.tr("SWMM Set default coefficient of friction") + + def shortHelpString(self): + return self.tr( + """ + Fill the attribute tww_od.reach.default_coefficient_of_friction where it is not filled. + If \"Overwrite existing default values\" is selected, all the default_coefficient_of_friction will be reseted. + See: https://qgep.github.io/docs/tww_swmm/coefficient_of_friction.html # TODO should point to new url // skip-keyword-check + """ + ) + + def helpUrl(self): + return "https://qgep.github.io/docs/tww_swmm/coefficient_of_friction.html" # TODO should point to new url // skip-keyword-check + + def initAlgorithm(self, config=None): + """Here we define the inputs and output of the algorithm, along + with some other properties. + """ + + # The parameters + description = self.tr("Database") + self.addParameter( + QgsProcessingParameterString( + self.DATABASE, description=description, defaultValue="pg_tww" + ) + ) + + description = self.tr("Overwrite existing default values") + self.addParameter( + QgsProcessingParameterBoolean( + self.OVERWRITE_VALUES, description=description, defaultValue=False + ) + ) + + def processAlgorithm( + self, parameters, context: QgsProcessingContext, feedback: QgsProcessingFeedback + ): + """Here is where the processing itself takes place.""" + + feedback.setProgress(0) + + # init params + database = self.parameterAsString(parameters, self.DATABASE, context) + overwrite_values = self.parameterAsBoolean(parameters, self.OVERWRITE_VALUES, context) + # Connect to TWW database and perform translation + with TwwSwmm(None, database, None, None, None, None, None, feedback) as qs: + qs.disable_reach_trigger() + if overwrite_values: + qs.overwrite_reach_default_friction() + else: + qs.set_reach_default_friction() + qs.enable_reach_trigger() + + feedback.setProgress(100) + + return {} diff --git a/plugin/teksi_wastewater/processing_provider/tww_algorithm.py b/plugin/teksi_wastewater/processing_provider/tww_algorithm.py new file mode 100644 index 000000000..4f1a5681e --- /dev/null +++ b/plugin/teksi_wastewater/processing_provider/tww_algorithm.py @@ -0,0 +1,49 @@ +""" +/*************************************************************************** + TWW processing provider + ------------------- + begin : 15.08.2018 + copyright : (C) 2018 by OPENGIS.ch + email : matthias@opengis.ch + ***************************************************************************/ + +/*************************************************************************** + * * + * 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. * + * * + ***************************************************************************/ +""" + +from PyQt5.QtCore import QCoreApplication +from qgis.core import QgsProcessingAlgorithm + +__author__ = "Matthias Kuhn" +__date__ = "2018-08-15" +__copyright__ = "(C) 2018 by OPENGIS.ch" + +# This will get replaced with a git SHA1 when you do a git archive + +__revision__ = "$Format:%H$" + + +class TwwAlgorithm(QgsProcessingAlgorithm): + """ + Boilerplate code for TWW algorithms + """ + + def group(self): + return "TWW" + + def groupId(self): + return "tww" + + def tr(self, string, context=""): + if context == "": + context = self.__class__.__name__ + return QCoreApplication.translate(context, string) + + def createInstance(self): + return type(self)() diff --git a/plugin/teksi_wastewater/svgprofile/.gitignore b/plugin/teksi_wastewater/svgprofile/.gitignore new file mode 100644 index 000000000..4683d3831 --- /dev/null +++ b/plugin/teksi_wastewater/svgprofile/.gitignore @@ -0,0 +1,2 @@ +*~ +dojo/ diff --git a/plugin/teksi_wastewater/svgprofile/d3.v2.min.js b/plugin/teksi_wastewater/svgprofile/d3.v2.min.js new file mode 100644 index 000000000..5cb4237f7 --- /dev/null +++ b/plugin/teksi_wastewater/svgprofile/d3.v2.min.js @@ -0,0 +1,4 @@ +(function(){function e(e,t){try{for(var n in t)Object.defineProperty(e.prototype,n,{value:t[n],enumerable:!1})}catch(r){e.prototype=t}}function t(e){var t=-1,n=e.length,r=[];while(++t=0?e.substring(t):(t=e.length,""),r=[];while(t>0)r.push(e.substring(t-=3,t+3));return r.reverse().join(",")+n}function b(e,t){var n=Math.pow(10,Math.abs(8-t)*3);return{scale:t>8?function(e){return e/n}:function(e){return e*n},symbol:e}}function w(e){return function(t){return t<=0?0:t>=1?1:e(t)}}function E(e){return function(t){return 1-e(1-t)}}function S(e){return function(t){return.5*(t<.5?e(2*t):2-e(2-2*t))}}function x(e){return e}function T(e){return function(t){return Math.pow(t,e)}}function N(e){return 1-Math.cos(e*Math.PI/2)}function C(e){return Math.pow(2,10*(e-1))}function k(e){return 1-Math.sqrt(1-e*e)}function L(e,t){var n;return arguments.length<2&&(t=.45),arguments.length<1?(e=1,n=t/4):n=t/(2*Math.PI)*Math.asin(1/e),function(r){return 1+e*Math.pow(2,10*-r)*Math.sin((r-n)*2*Math.PI/t)}}function A(e){return e||(e=1.70158),function(t){return t*t*((e+1)*t-e)}}function O(e){return e<1/2.75?7.5625*e*e:e<2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e<2.5/2.75?7.5625*(e-=2.25/2.75)*e+.9375:7.5625*(e-=2.625/2.75)*e+.984375}function M(){d3.event.stopPropagation(),d3.event.preventDefault()}function _(){var e=d3.event,t;while(t=e.sourceEvent)e=t;return e}function D(e){var t=new d,n=0,r=arguments.length;while(++n360?e-=360:e<0&&(e+=360),e<60?s+(o-s)*e/60:e<180?o:e<240?s+(o-s)*(240-e)/60:s}function i(e){return Math.round(r(e)*255)}var s,o;return e%=360,e<0&&(e+=360),t=t<0?0:t>1?1:t,n=n<0?0:n>1?1:n,o=n<=.5?n*(1+t):n+t-n*t,s=2*n-o,U(i(e+120),i(e),i(e-120))}function Z(e,t,n){return new et(e,t,n)}function et(e,t,n){this.h=e,this.c=t,this.l=n}function tt(e,t,n){return nt(n,Math.cos(e*=Math.PI/180)*t,Math.sin(e)*t)}function nt(e,t,n){return new rt(e,t,n)}function rt(e,t,n){this.l=e,this.a=t,this.b=n}function it(e,t,n){var r=(e+16)/116,i=r+t/500,s=r-n/200;return i=ot(i)*ys,r=ot(r)*bs,s=ot(s)*ws,U(at(3.2404542*i-1.5371385*r-.4985314*s),at(-0.969266*i+1.8760108*r+.041556*s),at(.0556434*i-.2040259*r+1.0572252*s))}function st(e,t,n){return Z(Math.atan2(n,t)/Math.PI*180,Math.sqrt(t*t+n*n),e)}function ot(e){return e>.206893034?e*e*e:(e-4/29)/7.787037}function ut(e){return e>.008856?Math.pow(e,1/3):7.787037*e+4/29}function at(e){return Math.round(255*(e<=.00304?12.92*e:1.055*Math.pow(e,1/2.4)-.055))}function ft(e){return Qi(e,ks),e}function lt(e){return function(){return Ss(e,this)}}function ct(e){return function(){return xs(e,this)}}function ht(e,t){function n(){this.removeAttribute(e)}function r(){this.removeAttributeNS(e.space,e.local)}function i(){this.setAttribute(e,t)}function s(){this.setAttributeNS(e.space,e.local,t)}function o(){var n=t.apply(this,arguments);n==null?this.removeAttribute(e):this.setAttribute(e,n)}function u(){var n=t.apply(this,arguments);n==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,n)}return e=d3.ns.qualify(e),t==null?e.local?r:n:typeof t=="function"?e.local?u:o:e.local?s:i}function pt(e){return new RegExp("(?:^|\\s+)"+d3.requote(e)+"(?:\\s+|$)","g")}function dt(e,t){function n(){var n=-1;while(++n0&&(e=e.substring(0,o)),t?i:r}function St(e,t){for(var n=0,r=e.length;nt?c():(v.active=t,i.forEach(function(t,n){(n=n.call(e,m,u))&&h.push(n)}),s.start.call(e,m,u),l(r)||d3.timer(l,0,n),1)}function l(n){if(v.active!==t)return c();var r=(n-p)/d,i=o(r),a=h.length;while(a>0)h[--a].call(e,i);if(r>=1)return c(),_s=t,s.end.call(e,m,u),_s=0,1}function c(){return--v.count||delete e.__transition__,1}var h=[],p=e.delay,d=e.duration,v=(e=e.node).__transition__||(e.__transition__={active:0,count:0}),m=e.__data__;++v.count,p<=r?f(r):d3.timer(f,p,n)})},0,n),e}function Nt(e){var t=_s,n=Fs,r=Bs,i=js;return _s=this.id,Fs=this.ease(),St(this,function(t,n,r){Bs=t.delay,js=t.duration,e.call(t=t.node,t.__data__,n,r)}),_s=t,Fs=n,Bs=r,js=i,this}function Ct(e,t,n){return n!=""&&Is}function kt(e,t){return d3.tween(e,F(t))}function Lt(){var e,t=Date.now(),n=Us;while(n)e=t-n.then,e>=n.delay&&(n.flush=n.callback(e)),n=n.next;var r=At()-t;r>24?(isFinite(r)&&(clearTimeout(Ws),Ws=setTimeout(Lt,r)),zs=0):(zs=1,Xs(Lt))}function At(){var e=null,t=Us,n=Infinity;while(t)t.flush?(delete Rs[t.callback.id],t=e?e.next=t.next:Us=t.next):(n=Math.min(n,t.then+t.delay),t=(e=t).next);return n}function Ot(e,t){var n=e.ownerSVGElement||e;if(n.createSVGPoint){var r=n.createSVGPoint();if(Vs<0&&(window.scrollX||window.scrollY)){n=d3.select(document.body).append("svg").style("position","absolute").style("top",0).style("left",0);var i=n[0][0].getScreenCTM();Vs=!i.f&&!i.e,n.remove()}return Vs?(r.x=t.pageX,r.y=t.pageY):(r.x=t.clientX,r.y=t.clientY),r=r.matrixTransform(e.getScreenCTM().inverse()),[r.x,r.y]}var s=e.getBoundingClientRect();return[t.clientX-s.left-e.clientLeft,t.clientY-s.top-e.clientTop]}function Mt(){}function _t(e){var t=e[0],n=e[e.length-1];return t2?zt:Ut,a=r?q:I;return o=i(e,t,a,n),u=i(t,e,a,d3.interpolate),s}function s(e){return o(e)}var o,u;return s.invert=function(e){return u(e)},s.domain=function(t){return arguments.length?(e=t.map(Number),i()):e},s.range=function(e){return arguments.length?(t=e,i()):t},s.rangeRound=function(e){return s.range(e).interpolate(d3.interpolateRound)},s.clamp=function(e){return arguments.length?(r=e,i()):r},s.interpolate=function(e){return arguments.length?(n=e,i()):n},s.ticks=function(t){return qt(e,t)},s.tickFormat=function(t){return Rt(e,t)},s.nice=function(){return Pt(e,Ft),i()},s.copy=function(){return Bt(e,t,n,r)},i()}function jt(e,t){return d3.rebind(e,t,"range","rangeRound","interpolate","clamp")}function Ft(e){return e=Math.pow(10,Math.round(Math.log(e)/Math.LN10)-1),e&&{floor:function(t){return Math.floor(t/e)*e},ceil:function(t){return Math.ceil(t/e)*e}}}function It(e,t){var n=_t(e),r=n[1]-n[0],i=Math.pow(10,Math.floor(Math.log(r/t)/Math.LN10)),s=t/r*i;return s<=.15?i*=10:s<=.35?i*=5:s<=.75&&(i*=2),n[0]=Math.ceil(n[0]/i)*i,n[1]=Math.floor(n[1]/i)*i+i*.5,n[2]=i,n}function qt(e,t){return d3.range.apply(d3,It(e,t))}function Rt(e,t){return d3.format(",."+Math.max(0,-Math.floor(Math.log(It(e,t)[2])/Math.LN10+.01))+"f")}function Ut(e,t,n,r){var i=n(e[0],e[1]),s=r(t[0],t[1]);return function(e){return s(i(e))}}function zt(e,t,n,r){var i=[],s=[],o=0,u=Math.min(e.length,t.length)-1;e[u]0;f--)i.push(r(s)*f)}else{for(;sa;o--);i=i.slice(s,o)}return i},n.tickFormat=function(e,i){arguments.length<2&&(i=$s);if(arguments.length<1)return i;var s=Math.max(.1,e/n.ticks().length),o=t===Vt?(u=-1e-12,Math.floor):(u=1e-12,Math.ceil),u;return function(e){return e/r(o(t(e)+u))<=s?i(e):""}},n.copy=function(){return Wt(e.copy(),t)},jt(n,e)}function Xt(e){return Math.log(e<0?0:e)/Math.LN10}function Vt(e){return-Math.log(e>0?0:-e)/Math.LN10}function $t(e,t){function n(t){return e(r(t))}var r=Jt(t),i=Jt(1/t);return n.invert=function(t){return i(e.invert(t))},n.domain=function(t){return arguments.length?(e.domain(t.map(r)),n):e.domain().map(i)},n.ticks=function(e){return qt(n.domain(),e)},n.tickFormat=function(e){return Rt(n.domain(),e)},n.nice=function(){return n.domain(Pt(n.domain(),Ft))},n.exponent=function(e){if(!arguments.length)return t;var s=n.domain();return r=Jt(t=e),i=Jt(1/t),n.domain(s)},n.copy=function(){return $t(e.copy(),t)},jt(n,e)}function Jt(e){return function(t){return t<0?-Math.pow(-t,e):Math.pow(t,e)}}function Kt(e,t){function n(t){return o[((s.get(t)||s.set(t,e.push(t)))-1)%o.length]}function i(t,n){return d3.range(e.length).map(function(e){return t+n*e})}var s,o,u;return n.domain=function(i){if(!arguments.length)return e;e=[],s=new r;var o=-1,u=i.length,a;while(++o1){u=t[1],s=e[a],a++,r+="C"+(i[0]+o[0])+","+(i[1]+o[1])+","+(s[0]-u[0])+","+(s[1]-u[1])+","+s[0]+","+s[1];for(var f=2;f9&&(s=n*3/Math.sqrt(s),o[u]=s*r,o[u+1]=s*i));u=-1;while(++u<=a)s=(e[Math.min(a,u+1)][0]-e[Math.max(0,u-1)][0])/(6*(1+o[u]*o[u])),t.push([s||0,o[u]*s||0]);return t}function Cn(e){return e.length<3?an(e):e[0]+vn(e,Nn(e))}function kn(e){var t,n=-1,r=e.length,i,s;while(++n1){var r=_t(e.domain()),i,s=-1,o=t.length,u=(t[1]-t[0])/++n,a,f;while(++s0;)(f=+t[s]-a*u)>=r[0]&&i.push(f);for(--s,a=0;++ar&&(n=t,r=i);return n}function sr(e){return e.reduce(or,0)}function or(e,t){return e+t[1]}function ur(e,t){return ar(e,Math.ceil(Math.log(t.length)/Math.LN2+1))}function ar(e,t){var n=-1,r=+e[0],i=(e[1]-r)/t,s=[];while(++n<=t)s[n]=i*n+r;return s}function fr(e){return[d3.min(e),d3.max(e)]}function lr(e,t){return d3.rebind(e,t,"sort","children","value"),e.links=dr,e.nodes=function(t){return vo=!0,(e.nodes=e)(t)},e}function cr(e){return e.children}function hr(e){return e.value}function pr(e,t){return t.value-e.value}function dr(e){return d3.merge(e.map(function(e){return(e.children||[]).map(function(t){return{source:e,target:t}})}))}function vr(e,t){return e.value-t.value}function mr(e,t){var n=e._pack_next;e._pack_next=t,t._pack_prev=e,t._pack_next=n,n._pack_prev=t}function gr(e,t){e._pack_next=t,t._pack_prev=e}function yr(e,t){var n=t.x-e.x,r=t.y-e.y,i=e.r+t.r;return i*i-n*n-r*r>.001}function br(e){function t(e){r=Math.min(e.x-e.r,r),i=Math.max(e.x+e.r,i),s=Math.min(e.y-e.r,s),o=Math.max(e.y+e.r,o)}if(!(n=e.children)||!(p=n.length))return;var n,r=Infinity,i=-Infinity,s=Infinity,o=-Infinity,u,a,f,l,c,h,p;n.forEach(wr),u=n[0],u.x=-u.r,u.y=0,t(u);if(p>1){a=n[1],a.x=a.r,a.y=0,t(a);if(p>2){f=n[2],xr(u,a,f),t(f),mr(u,f),u._pack_prev=f,mr(f,a),a=u._pack_next;for(l=3;l0&&(e=r)}return e}function _r(e,t){return e.x-t.x}function Dr(e,t){return t.x-e.x}function Pr(e,t){return e.depth-t.depth}function Hr(e,t){function n(e,r){var i=e.children;if(i&&(a=i.length)){var s,o=null,u=-1,a;while(++u=0)s=r[i]._tree,s.prelim+=t,s.mod+=t,t+=s.shift+(n+=s.change)}function jr(e,t,n){e=e._tree,t=t._tree;var r=n/(t.number-e.number);e.change+=r,t.change-=r,t.shift+=n,t.prelim+=n,t.mod+=n}function Fr(e,t,n){return e._tree.ancestor.parent==t.parent?e._tree.ancestor:n}function Ir(e){return{x:e.x,y:e.y,dx:e.dx,dy:e.dy}}function qr(e,t){var n=e.x+t[3],r=e.y+t[0],i=e.dx-t[1]-t[3],s=e.dy-t[0]-t[2];return i<0&&(n+=i/2,i=0),s<0&&(r+=s/2,s=0),{x:n,y:r,dx:i,dy:s}}function Rr(e,t){function n(e,r){d3.text(e,t,function(e){r(e&&n.parse(e))})}function r(t){return t.map(i).join(e)}function i(e){return o.test(e)?'"'+e.replace(/\"/g,'""')+'"':e}var s=new RegExp("\r\n|["+e+"\r\n]","g"),o=new RegExp('["'+e+"\n]"),u=e.charCodeAt(0);return n.parse=function(e){var t;return n.parseRows(e,function(e,n){if(n){var r={},i=-1,s=t.length;while(++i=e.length)return i;if(l)return l=!1,r;var t=s.lastIndex;if(e.charCodeAt(t)===34){var n=t;while(n++0}function si(e,t,n){return(n[0]-t[0])*(e[1]-t[1])<(n[1]-t[1])*(e[0]-t[0])}function oi(e,t,n,r){var i=e[0],s=t[0],o=n[0],u=r[0],a=e[1],f=t[1],l=n[1],c=r[1],h=i-o,p=s-i,d=u-o,v=a-l,m=f-a,g=c-l,y=(d*v-g*h)/(g*p-d*m);return[i+y*p,a+y*m]}function ui(e,t){var n={list:e.map(function(e,t){return{index:t,x:e[0],y:e[1]}}).sort(function(e,t){return e.yt.y?1:e.xt.x?1:0}),bottomSite:null},r={list:[],leftEnd:null,rightEnd:null,init:function(){r.leftEnd=r.createHalfEdge(null,"l"),r.rightEnd=r.createHalfEdge(null,"l"),r.leftEnd.r=r.rightEnd,r.rightEnd.l=r.leftEnd,r.list.unshift(r.leftEnd,r.rightEnd)},createHalfEdge:function(e,t){return{edge:e,side:t,vertex:null,l:null,r:null}},insert:function(e,t){t.l=e,t.r=e.r,e.r.l=t,e.r=t},leftBound:function(e){var t=r.leftEnd;do t=t.r;while(t!=r.rightEnd&&i.rightOf(t,e));return t=t.l,t},del:function(e){e.l.r=e.r,e.r.l=e.l,e.edge=null},right:function(e){return e.r},left:function(e){return e.l},leftRegion:function(e){return e.edge==null?n.bottomSite:e.edge.region[e.side]},rightRegion:function(e){return e.edge==null?n.bottomSite:e.edge.region[wo[e.side]]}},i={bisect:function(e,t){var n={region:{l:e,r:t},ep:{l:null,r:null}},r=t.x-e.x,i=t.y-e.y,s=r>0?r:-r,o=i>0?i:-i;return n.c=e.x*r+e.y*i+(r*r+i*i)*.5,s>o?(n.a=1,n.b=i/r,n.c/=r):(n.b=1,n.a=r/i,n.c/=i),n},intersect:function(e,t){var n=e.edge,r=t.edge;if(!n||!r||n.region.r==r.region.r)return null;var i=n.a*r.b-n.b*r.a;if(Math.abs(i)<1e-10)return null;var s=(n.c*r.b-r.c*n.b)/i,o=(r.c*n.a-n.c*r.a)/i,u=n.region.r,a=r.region.r,f,l;u.y=l.region.r.x;return c&&f.side==="l"||!c&&f.side==="r"?null:{x:s,y:o}},rightOf:function(e,t){var n=e.edge,r=n.region.r,i=t.x>r.x;if(i&&e.side==="l")return 1;if(!i&&e.side==="r")return 0;if(n.a===1){var s=t.y-r.y,o=t.x-r.x,u=0,a=0;!i&&n.b<0||i&&n.b>=0?a=u=s>=n.b*o:(a=t.x+t.y*n.b>n.c,n.b<0&&(a=!a),a||(u=1));if(!u){var f=r.x-n.region.l.x;a=n.b*(o*o-s*s)h*h+p*p}return e.side==="l"?a:!a},endPoint:function(e,n,r){e.ep[n]=r;if(!e.ep[wo[n]])return;t(e)},distance:function(e,t){var n=e.x-t.x,r=e.y-t.y;return Math.sqrt(n*n+r*r)}},s={list:[],insert:function(e,t,n){e.vertex=t,e.ystar=t.y+n;for(var r=0,i=s.list,o=i.length;ru.ystar||e.ystar==u.ystar&&t.x>u.vertex.x)continue;break}i.splice(r,0,e)},del:function(e){for(var t=0,n=s.list,r=n.length;td.y&&(v=p,p=d,d=v,b="r"),y=i.bisect(p,d),h=r.createHalfEdge(y,b),r.insert(l,h),i.endPoint(y,wo[b],g),m=i.intersect(l,h),m&&(s.del(l),s.insert(l,m,i.distance(m,p))),m=i.intersect(h,c),m&&s.insert(h,m,i.distance(m,p))}}for(a=r.right(r.leftEnd);a!=r.rightEnd;a=r.right(a))t(a.edge)}function ai(){return{leaf:!0,nodes:[],point:null}}function fi(e,t,n,r,i,s){if(!e(t,n,r,i,s)){var o=(n+i)*.5,u=(r+s)*.5,a=t.nodes;a[0]&&fi(e,a[0],n,r,o,u),a[1]&&fi(e,a[1],o,r,i,u),a[2]&&fi(e,a[2],n,u,o,s),a[3]&&fi(e,a[3],o,u,i,s)}}function li(e){return{x:e[0],y:e[1]}}function ci(){this._=new Date(arguments.length>1?Date.UTC.apply(this,arguments):arguments[0])}function hi(e){return e.substring(0,3)}function pi(e,t,n,r){var i,s,o=0,u=t.length,a=n.length;while(o=a)return-1;i=t.charCodeAt(o++);if(i==37){s=Uo[t.charAt(o++)];if(!s||(r=s(e,n,r))<0)return-1}else if(i!=n.charCodeAt(r++))return-1}return r}function di(e){return new RegExp("^(?:"+e.map(d3.requote).join("|")+")","i")}function vi(e){var t=new r,n=-1,i=e.length;while(++n68?1900:2e3)}function Ci(e,t,n){zo.lastIndex=0;var r=zo.exec(t.substring(n,n+2));return r?(e.m=r[0]-1,n+=r[0].length):-1}function ki(e,t,n){zo.lastIndex=0;var r=zo.exec(t.substring(n,n+2));return r?(e.d=+r[0],n+=r[0].length):-1}function Li(e,t,n){zo.lastIndex=0;var r=zo.exec(t.substring(n,n+2));return r?(e.H=+r[0],n+=r[0].length):-1}function Ai(e,t,n){zo.lastIndex=0;var r=zo.exec(t.substring(n,n+2));return r?(e.M=+r[0],n+=r[0].length):-1}function Oi(e,t,n){zo.lastIndex=0;var r=zo.exec(t.substring(n,n+2));return r?(e.S=+r[0],n+=r[0].length):-1}function Mi(e,t,n){zo.lastIndex=0;var r=zo.exec(t.substring(n,n+3));return r?(e.L=+r[0],n+=r[0].length):-1}function _i(e,t,n){var r=Wo.get(t.substring(n,n+=2).toLowerCase());return r==null?-1:(e.p=r,n)}function Di(e){var t=e.getTimezoneOffset(),n=t>0?"-":"+",r=~~(Math.abs(t)/60),i=Math.abs(t)%60;return n+Mo(r)+Mo(i)}function Pi(e){return e.toISOString()}function Hi(e,t,n){function r(t){var n=e(t),r=s(n,1);return t-n1)while(ot?1:e>=t?0:NaN},d3.descending=function(e,t){return te?1:t>=e?0:NaN},d3.mean=function(e,t){var n=e.length,r,i=0,s=-1,o=0;if(arguments.length===1)while(++s1&&(e=e.map(t)),e=e.filter(f),e.length?d3.quantile(e.sort(d3.ascending),.5):undefined},d3.min=function(e,t){var n=-1,r=e.length,i,s;if(arguments.length===1){while(++ns&&(i=s)}else{while(++ns&&(i=s)}return i},d3.max=function(e,t){var n=-1,r=e.length,i,s;if(arguments.length===1){while(++ni&&(i=s)}else{while(++ni&&(i=s)}return i},d3.extent=function(e,t){var n=-1,r=e.length,i,s,o;if(arguments.length===1){while(++ns&&(i=s),os&&(i=s),o1);return e+t*n*Math.sqrt(-2*Math.log(i)/i)}},logNormal:function(e,t){var n=arguments.length;n<2&&(t=1),n<1&&(e=0);var r=d3.random.normal();return function(){return Math.exp(e+t*r())}},irwinHall:function(e){return function(){for(var t=0,n=0;n>>1;e.call(t,t[s],s)>>1;n0&&(i=s);return i},d3.last=function(e,t){var n=0,r=e.length,i=e[0],s;arguments.length===1&&(t=d3.ascending);while(++n=i.length)return u?u.call(n,t):o?t.sort(o):t;var a=-1,f=t.length,l=i[s++],c,h,p=new r,d,v={};while(++a=i.length)return e;var r=[],o=s[n++],u;for(u in e)r.push({key:u,values:t(e[u],n)});return o&&r.sort(function(e,t){return o(e.key,t.key)}),r}var n={},i=[],s=[],o,u;return n.map=function(t){return e(t,0)},n.entries=function(n){return t(e(n,0),0)},n.key=function(e){return i.push(e),n},n.sortKeys=function(e){return s[i.length-1]=e,n},n.sortValues=function(e){return o=e,n},n.rollup=function(e){return u=e,n},n},d3.keys=function(e){var t=[];for(var n in e)t.push(n);return t},d3.values=function(e){var t=[];for(var n in e)t.push(e[n]);return t},d3.entries=function(e){var t=[];for(var n in e)t.push({key:n,value:e[n]});return t},d3.permute=function(e,t){var n=[],r=-1,i=t.length;while(++rt)r.push(o/i);else while((o=e+n*++s)=200&&e<300||e===304?r:null)}},r.send(null)},d3.text=function(e,t,n){function r(e){n(e&&e.responseText)}arguments.length<3&&(n=t,t=null),d3.xhr(e,t,r)},d3.json=function(e,t){d3.text(e,"application/json",function(e){t(e?JSON.parse(e):null)})},d3.html=function(e,t){d3.text(e,"text/html",function(e){if(e!=null){var n=document.createRange();n.selectNode(document.body),e=n.createContextualFragment(e)}t(e)})},d3.xml=function(e,t,n){function r(e){n(e&&e.responseXML)}arguments.length<3&&(n=t,t=null),d3.xhr(e,t,r)};var ts={svg:"http://www.w3.org/2000/svg",xhtml:"http://www.w3.org/1999/xhtml",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};d3.ns={prefix:ts,qualify:function(e){var t=e.indexOf(":"),n=e;return t>=0&&(n=e.substring(0,t),e=e.substring(t+1)),ts.hasOwnProperty(n)?{space:ts[n],local:e}:e}},d3.dispatch=function(){var e=new d,t=-1,n=arguments.length;while(++t0&&(r=e.substring(n+1),e=e.substring(0,n)),arguments.length<2?this[e].on(r):this[e].on(r,t)},d3.format=function(e){var t=ns.exec(e),n=t[1]||" ",r=t[3]||"",i=t[5],s=+t[6],o=t[7],u=t[8],a=t[9],f=1,l="",c=!1;u&&(u=+u.substring(1)),i&&(n="0",o&&(s-=Math.floor((s-1)/4)));switch(a){case"n":o=!0,a="g";break;case"%":f=100,l="%",a="f";break;case"p":f=100,l="%",a="r";break;case"d":c=!0,u=0;break;case"s":f=-1,a="r"}return a=="r"&&!u&&(a="g"),a=rs.get(a)||g,function(e){if(c&&e%1)return"";var t=e<0&&(e=-e)?"-":r;if(f<0){var h=d3.formatPrefix(e,u);e=h.scale(e),l=h.symbol}else e*=f;e=a(e,u);if(i){var p=e.length+t.length;p=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/,rs=d3.map({g:function(e,t){return e.toPrecision(t)},e:function(e,t){return e.toExponential(t)},f:function(e,t){return e.toFixed(t)},r:function(e,t){return d3.round(e,t=m(e,t)).toFixed(Math.max(0,Math.min(20,t)))}}),is=["y","z","a","f","p","n","μ","m","","k","M","G","T","P","E","Z","Y"].map(b);d3.formatPrefix=function(e,t){var n=0;return e&&(e<0&&(e*=-1),t&&(e=d3.round(e,m(e,t))),n=1+Math.floor(1e-12+Math.log(e)/Math.LN10),n=Math.max(-24,Math.min(24,Math.floor((n<=0?n+1:n-1)/3)*3))),is[8+n/3]};var ss=T(2),os=T(3),us=function(){return x},as=d3.map({linear:us,poly:T,quad:function(){return ss},cubic:function(){return os},sin:function(){return N},exp:function(){return C},circle:function(){return k},elastic:L,back:A,bounce:function(){return O}}),fs=d3.map({"in":x,out:E,"in-out":S,"out-in":function(e){return S(E(e))}});d3.ease=function(e){var t=e.indexOf("-"),n=t>=0?e.substring(0,t):e,r=t>=0?e.substring(t+1):"in";return n=as.get(n)||us,r=fs.get(r)||x,w(r(n.apply(null,Array.prototype.slice.call(arguments,1))))},d3.event=null,d3.transform=function(e){var t=document.createElementNS(d3.ns.prefix.svg,"g");return(d3.transform=function(e){t.setAttribute("transform",e);var n=t.transform.baseVal.consolidate();return new P(n?n.matrix:cs)})(e)},P.prototype.toString=function(){return"translate("+this.translate+")rotate("+this.rotate+")skewX("+this.skew+")scale("+this.scale+")"};var ls=180/Math.PI,cs={a:1,b:0,c:0,d:1,e:0,f:0};d3.interpolate=function(e,t){var n=d3.interpolators.length,r;while(--n>=0&&!(r=d3.interpolators[n](e,t)));return r},d3.interpolateNumber=function(e,t){return t-=e,function(n){return e+t*n}},d3.interpolateRound=function(e,t){return t-=e,function(n){return Math.round(e+t*n)}},d3.interpolateString=function(e,t){var n,r,i,s=0,o=0,u=[],a=[],f,l;hs.lastIndex=0;for(r=0;n=hs.exec(t);++r)n.index&&u.push(t.substring(s,o=n.index)),a.push({i:u.length,x:n[0]}),u.push(null),s=hs.lastIndex;s180?l+=360:l-f>180&&(f+=360),r.push({i:n.push(n.pop()+"rotate(",null,")")-2,x:d3.interpolateNumber(f,l)})):l&&n.push(n.pop()+"rotate("+l+")"),c!=h?r.push({i:n.push(n.pop()+"skewX(",null,")")-2,x:d3.interpolateNumber(c,h)}):h&&n.push(n.pop()+"skewX("+h+")"),p[0]!=d[0]||p[1]!=d[1]?(i=n.push(n.pop()+"scale(",null,",",null,")"),r.push({i:i-4,x:d3.interpolateNumber(p[0],d[0])},{i:i-2,x:d3.interpolateNumber(p[1],d[1])})):(d[0]!=1||d[1]!=1)&&n.push(n.pop()+"scale("+d+")"),i=r.length,function(e){var t=-1,s;while(++t180?s-=360:s<-180&&(s+=360),function(e){return Y(n+s*e,r+o*e,i+u*e)+""}},d3.interpolateLab=function(e,t){e=d3.lab(e),t=d3.lab(t);var n=e.l,r=e.a,i=e.b,s=t.l-n,o=t.a-r,u=t.b-i;return function(e){return it(n+s*e,r+o*e,i+u*e)+""}},d3.interpolateHcl=function(e,t){e=d3.hcl(e),t=d3.hcl(t);var n=e.h,r=e.c,i=e.l,s=t.h-n,o=t.c-r,u=t.l-i;return s>180?s-=360:s<-180&&(s+=360),function(e){return tt(n+s*e,r+o*e,i+u*e)+""}},d3.interpolateArray=function(e,t){var n=[],r=[],i=e.length,s=t.length,o=Math.min(e.length,t.length),u;for(u=0;u=0;)if(s=n[r])i&&i!==s.nextSibling&&i.parentNode.insertBefore(s,i),i=s;return this},ks.sort=function(e){e=wt.apply(this,arguments);for(var t=-1,n=this.length;++t=Zs?e?"M0,"+s+"A"+s+","+s+" 0 1,1 0,"+ -s+"A"+s+","+s+" 0 1,1 0,"+s+"M0,"+e+"A"+e+","+e+" 0 1,0 0,"+ -e+"A"+e+","+e+" 0 1,0 0,"+e+"Z":"M0,"+s+"A"+s+","+s+" 0 1,1 0,"+ -s+"A"+s+","+s+" 0 1,1 0,"+s+"Z":e?"M"+s*l+","+s*c+"A"+s+","+s+" 0 "+f+",1 "+s*h+","+s*p+"L"+e*h+","+e*p+"A"+e+","+e+" 0 "+f+",0 "+e*l+","+e*c+"Z":"M"+s*l+","+s*c+"A"+s+","+s+" 0 "+f+",1 "+s*h+","+s*p+"L0,0"+"Z"}var t=en,n=tn,r=nn,i=rn;return e.innerRadius=function(n){return arguments.length?(t=u(n),e):t},e.outerRadius=function(t){return arguments.length?(n=u(t),e):n},e.startAngle=function(t){return arguments.length?(r=u(t),e):r},e.endAngle=function(t){return arguments.length?(i=u(t),e):i},e.centroid=function(){var e=(t.apply(this,arguments)+n.apply(this,arguments))/2,s=(r.apply(this,arguments)+i.apply(this,arguments))/2+Ys;return[Math.cos(s)*e,Math.sin(s)*e]},e};var Ys=-Math.PI/2,Zs=2*Math.PI-1e-6;d3.svg.line=function(){return sn(i)};var eo=d3.map({linear:an,"linear-closed":fn,"step-before":ln,"step-after":cn,basis:gn,"basis-open":yn,"basis-closed":bn,bundle:wn,cardinal:dn,"cardinal-open":hn,"cardinal-closed":pn,monotone:Cn});eo.forEach(function(e,t){t.key=e,t.closed=/-closed$/.test(e)});var to=[0,2/3,1/3,0],no=[0,1/3,2/3,0],ro=[0,1/6,2/3,1/6];d3.svg.line.radial=function(){var e=sn(kn);return e.radius=e.x,delete e.x,e.angle=e.y,delete e.y,e},ln.reverse=cn,cn.reverse=ln,d3.svg.area=function(){return Ln(i)},d3.svg.area.radial=function(){var e=Ln(kn);return e.radius=e.x,delete e.x,e.innerRadius=e.x0,delete e.x0,e.outerRadius=e.x1,delete e.x1,e.angle=e.y,delete e.y,e.startAngle=e.y0,delete e.y0,e.endAngle=e.y1,delete e.y1,e},d3.svg.chord=function(){function e(e,u){var a=t(this,s,e,u),f=t(this,o,e,u);return"M"+a.p0+r(a.r,a.p1,a.a1-a.a0)+(n(a,f)?i(a.r,a.p1,a.r,a.p0):i(a.r,a.p1,f.r,f.p0)+r(f.r,f.p1,f.a1-f.a0)+i(f.r,f.p1,a.r,a.p0))+"Z"}function t(e,t,n,r){var i=t.call(e,n,r),s=a.call(e,i,r),o=f.call(e,i,r)+Ys,u=l.call(e,i,r)+Ys;return{r:s,a0:o,a1:u,p0:[s*Math.cos(o),s*Math.sin(o)],p1:[s*Math.cos(u),s*Math.sin(u)]}}function n(e,t){return e.a0==t.a0&&e.a1==t.a1}function r(e,t,n){return"A"+e+","+e+" 0 "+ +(n>Math.PI)+",1 "+t}function i(e,t,n,r){return"Q 0,0 "+r}var s=An,o=On,a=Mn,f=nn,l=rn;return e.radius=function(t){return arguments.length?(a=u(t),e):a},e.source=function(t){return arguments.length?(s=u(t),e):s},e.target=function(t){return arguments.length?(o=u(t),e):o},e.startAngle=function(t){return arguments.length?(f=u(t),e):f},e.endAngle=function(t){return arguments.length?(l=u(t),e):l},e},d3.svg.diagonal=function(){function e(e,i){var s=t.call(this,e,i),o=n.call(this,e,i),u=(s.y+o.y)/2,a=[s,{x:s.x,y:u},{x:o.x,y:u},o];return a=a.map(r),"M"+a[0]+"C"+a[1]+" "+a[2]+" "+a[3]}var t=An,n=On,r=Pn;return e.source=function(n){return arguments.length?(t=u(n),e):t},e.target=function(t){return arguments.length?(n=u(t),e):n},e.projection=function(t){return arguments.length?(r=t,e):r},e},d3.svg.diagonal.radial=function(){var e=d3.svg.diagonal(),t=Pn,n=e.projection;return e.projection=function(e){return arguments.length?n(Hn(t=e)):t},e},d3.svg.mouse=d3.mouse,d3.svg.touches=d3.touches,d3.svg.symbol=function(){function e(e,r){return(io.get(t.call(this,e,r))||Fn)(n.call(this,e,r))}var t=jn,n=Bn;return e.type=function(n){return arguments.length?(t=u(n),e):t},e.size=function(t){return arguments.length?(n=u(t),e):n},e};var io=d3.map({circle:Fn,cross:function(e){var t=Math.sqrt(e/5)/2;return"M"+ -3*t+","+ -t+"H"+ -t+"V"+ -3*t+"H"+t+"V"+ -t+"H"+3*t+"V"+t+"H"+t+"V"+3*t+"H"+ -t+"V"+t+"H"+ -3*t+"Z"},diamond:function(e){var t=Math.sqrt(e/(2*oo)),n=t*oo;return"M0,"+ -t+"L"+n+",0"+" 0,"+t+" "+ -n+",0"+"Z"},square:function(e){var t=Math.sqrt(e)/2;return"M"+ -t+","+ -t+"L"+t+","+ -t+" "+t+","+t+" "+ -t+","+t+"Z"},"triangle-down":function(e){var t=Math.sqrt(e/so),n=t*so/2;return"M0,"+n+"L"+t+","+ -n+" "+ -t+","+ -n+"Z"},"triangle-up":function(e){var t=Math.sqrt(e/so),n=t*so/2;return"M0,"+ -n+"L"+t+","+n+" "+ -t+","+n+"Z"}});d3.svg.symbolTypes=io.keys();var so=Math.sqrt(3),oo=Math.tan(30*Math.PI/180);d3.svg.axis=function(){function e(e){e.each(function(){var e=d3.select(this),c=a==null?t.ticks?t.ticks.apply(t,u):t.domain():a,h=f==null?t.tickFormat?t.tickFormat.apply(t,u):String:f,p=Rn(t,c,l),d=e.selectAll(".minor").data(p,String),v=d.enter().insert("line","g").attr("class","tick minor").style("opacity",1e-6),m=d3.transition(d.exit()).style("opacity",1e-6).remove(),g=d3.transition(d).style("opacity",1),y=e.selectAll("g").data(c,String),b=y.enter().insert("g","path").style("opacity",1e-6),w=d3.transition(y.exit()).style("opacity",1e-6).remove(),E=d3.transition(y).style("opacity",1),S,x=Dt(t),T=e.selectAll(".domain").data([0]),N=T.enter().append("path").attr("class","domain"),C=d3.transition(T),k=t.copy(),L=this.__chart__||k;this.__chart__=k,b.append("line").attr("class","tick"),b.append("text");var A=b.select("line"),O=E.select("line"),M=y.select("text").text(h),_=b.select("text"),D=E.select("text");switch(n){case"bottom":S=In,v.attr("y2",i),g.attr("x2",0).attr("y2",i),A.attr("y2",r),_.attr("y",Math.max(r,0)+o),O.attr("x2",0).attr("y2",r),D.attr("x",0).attr("y",Math.max(r,0)+o),M.attr("dy",".71em").attr("text-anchor","middle"),C.attr("d","M"+x[0]+","+s+"V0H"+x[1]+"V"+s);break;case"top":S=In,v.attr("y2",-i),g.attr("x2",0).attr("y2",-i),A.attr("y2",-r),_.attr("y",-(Math.max(r,0)+o)),O.attr("x2",0).attr("y2",-r),D.attr("x",0).attr("y",-(Math.max(r,0)+o)),M.attr("dy","0em").attr("text-anchor","middle"),C.attr("d","M"+x[0]+","+ -s+"V0H"+x[1]+"V"+ -s);break;case"left":S=qn,v.attr("x2",-i),g.attr("x2",-i).attr("y2",0),A.attr("x2",-r),_.attr("x",-(Math.max(r,0)+o)),O.attr("x2",-r).attr("y2",0),D.attr("x",-(Math.max(r,0)+o)).attr("y",0),M.attr("dy",".32em").attr("text-anchor","end"),C.attr("d","M"+ -s+","+x[0]+"H0V"+x[1]+"H"+ -s);break;case"right":S=qn,v.attr("x2",i),g.attr("x2",i).attr("y2",0),A.attr("x2",r),_.attr("x",Math.max(r,0)+o),O.attr("x2",r).attr("y2",0),D.attr("x",Math.max(r,0)+o).attr("y",0),M.attr("dy",".32em").attr("text-anchor","start"),C.attr("d","M"+s+","+x[0]+"H0V"+x[1]+"H"+s)}if(t.ticks)b.call(S,L),E.call(S,k),w.call(S,k),v.call(S,L),g.call(S,k),m.call(S,k);else{var P=k.rangeBand()/2,H=function(e){return k(e)+P};b.call(S,H),E.call(S,H)}})}var t=d3.scale.linear(),n="bottom",r=6,i=6,s=6,o=3,u=[10],a=null,f,l=0;return e.scale=function(n){return arguments.length?(t=n,e):t},e.orient=function(t){return arguments.length?(n=t,e):n},e.ticks=function(){return arguments.length?(u=arguments,e):u},e.tickValues=function(t){return arguments.length?(a=t,e):a},e.tickFormat=function(t){return arguments.length?(f=t,e):f},e.tickSize=function(t,n,o){if(!arguments.length)return r;var u=arguments.length-1;return r=+t,i=u>1?+n:r,s=u>0?+arguments[u]:r,e},e.tickPadding=function(t){return arguments.length?(o=+t,e):o},e.tickSubdivide=function(t){return arguments.length?(l=+t,e):l},e},d3.svg.brush=function(){function e(s){s.each(function(){var s=d3.select(this),f=s.selectAll(".background").data([0]),l=s.selectAll(".extent").data([0]),c=s.selectAll(".resize").data(a,String),h;s.style("pointer-events","all").on("mousedown.brush",i).on("touchstart.brush",i),f.enter().append("rect").attr("class","background").style("visibility","hidden").style("cursor","crosshair"),l.enter().append("rect").attr("class","extent").style("cursor","move"),c.enter().append("g").attr("class",function(e){return"resize "+e}).style("cursor",function(e){return uo[e]}).append("rect").attr("x",function(e){return/[ew]$/.test(e)?-3:null}).attr("y",function(e){return/^[ns]/.test(e)?-3:null}).attr("width",6).attr("height",6).style("visibility","hidden"),c.style("display",e.empty()?"none":null),c.exit().remove(),o&&(h=Dt(o),f.attr("x",h[0]).attr("width",h[1]-h[0]),n(s)),u&&(h=Dt(u),f.attr("y",h[0]).attr("height",h[1]-h[0]),r(s)),t(s)})}function t(e){e.selectAll(".resize").attr("transform",function(e){return"translate("+f[+/e$/.test(e)][0]+","+f[+/^s/.test(e)][1]+")"})}function n(e){e.select(".extent").attr("x",f[0][0]),e.selectAll(".extent,.n>rect,.s>rect").attr("width",f[1][0]-f[0][0])}function r(e){e.select(".extent").attr("y",f[0][1]),e.selectAll(".extent,.e>rect,.w>rect").attr("height",f[1][1]-f[0][1])}function i(){function i(){var e=d3.event.changedTouches;return e?d3.touches(v,e)[0]:d3.mouse(v)}function a(){d3.event.keyCode==32&&(S||(x=null,T[0]-=f[1][0],T[1]-=f[1][1],S=2),M())}function c(){d3.event.keyCode==32&&S==2&&(T[0]+=f[1][0],T[1]+=f[1][1],S=0,M())}function h(){var e=i(),s=!1;N&&(e[0]+=N[0],e[1]+=N[1]),S||(d3.event.altKey?(x||(x=[(f[0][0]+f[1][0])/2,(f[0][1]+f[1][1])/2]),T[0]=f[+(e[0]0?a=e:a=0:e>0&&(r.start({type:"start",alpha:a=e}),d3.timer(n.tick)),n):a},n.start=function(){function e(e,n){var i=t(r),s=-1,o=i.length,u;while(++si&&(i=u),r.push(u)}for(o=0;o0){s=-1;while(++s=a[0]&&d<=a[1]&&(l=o[d3.bisect(f,d,1,h)-1],l.y+=p,l.push(e[s]))}return o}var t=!0,n=Number,r=fr,i=ur;return e.value=function(t){return arguments.length?(n=t,e):n},e.range=function(t){return arguments.length?(r=u(t),e):r},e.bins=function(t){return arguments.length?(i=typeof t=="number"?function(e){return ar(e,t)}:u(t),e):i},e.frequency=function(n){return arguments.length?(t=!!n,e):t},e},d3.layout.hierarchy=function(){function e(t,o,u){var a=i.call(n,t,o),f=vo?t:{data:t};f.depth=o,u.push(f);if(a&&(c=a.length)){var l=-1,c,h=f.children=[],p=0,d=o+1,v;while(++l0){var l=n*f/2;Hr(o,function(e){e.r+=l}),Hr(o,br),Hr(o,function(e){e.r-=l}),f=Math.max(2*o.r/u,2*o.r/a)}return Sr(o,u/2,a/2,1/f),s}var t=d3.layout.hierarchy().sort(vr),n=0,r=[1,1];return e.size=function(t){return arguments.length?(r=t,e):r},e.padding=function(t){return arguments.length?(n=+t,e):n},lr(e,t)},d3.layout.cluster=function(){function e(e,i){var s=t.call(this,e,i),o=s[0],u,a=0,f,l;Hr(o,function(e){var t=e.children;t&&t.length?(e.x=Nr(t),e.y=Tr(t)):(e.x=u?a+=n(e,u):0,e.y=0,u=e)});var c=Cr(o),h=kr(o),p=c.x-n(c,h)/2,d=h.x+n(h,c)/2;return Hr(o,function(e){e.x=(e.x-p)/(d-p)*r[0],e.y=(1-(o.y?e.y/o.y:1))*r[1]}),s}var t=d3.layout.hierarchy().sort(null).value(null),n=Lr,r=[1,1];return e.separation=function(t){return arguments.length?(n=t,e):n},e.size=function(t){return arguments.length?(r=t,e):r},lr(e,t)},d3.layout.tree=function(){function e(e,i){function s(e,t){var r=e.children,i=e._tree;if(r&&(o=r.length)){var o,a=r[0],f,l=a,c,h=-1;while(++h0&&(jr(Fr(o,e,r),e,h),a+=h,f+=h),l+=o._tree.mod,a+=i._tree.mod,c+=u._tree.mod,f+=s._tree.mod;o&&!Or(s)&&(s._tree.thread=o,s._tree.mod+=l-f),i&&!Ar(u)&&(u._tree.thread=i,u._tree.mod+=a-c,r=e)}return r}var a=t.call(this,e,i),f=a[0];Hr(f,function(e,t){e._tree={ancestor:e,prelim:0,mod:0,change:0,shift:0,number:t?t._tree.number+1:0}}),s(f),o(f,-f._tree.prelim);var l=Mr(f,Dr),c=Mr(f,_r),h=Mr(f,Pr),p=l.x-n(l,c)/2,d=c.x+n(c,l)/2,v=h.depth||1;return Hr(f,function(e){e.x=(e.x-p)/(d-p)*r[0],e.y=e.depth/v*r[1],delete e._tree}),a}var t=d3.layout.hierarchy().sort(null).value(null),n=Lr,r=[1,1];return e.separation=function(t){return arguments.length?(n=t,e):n},e.size=function(t){return arguments.length?(r=t,e):r},lr(e,t)},d3.layout.treemap=function(){function e(e,t){var n=-1,r=e.length,i,s;while(++n0)u.push(f=a[d-1]),u.area+=f.area,(h=r(u,p))<=c?(a.pop(),c=h):(u.area-=u.pop().area,i(u,p,o,!1),p=Math.min(o.dx,o.dy),u.length=u.area=0,c=Infinity);u.length&&(i(u,p,o,!0),u.length=u.area=0),s.forEach(t)}}function n(t){var r=t.children;if(r&&r.length){var s=l(t),o=r.slice(),u,a=[];e(o,s.dx*s.dy/t.value),a.area=0;while(u=o.pop())a.push(u),a.area+=u.area,u.z!=null&&(i(a,u.z?s.dx:s.dy,s,!o.length),a.length=a.area=0);r.forEach(n)}}function r(e,t){var n=e.area,r,i=0,s=Infinity,o=-1,u=e.length;while(++oi&&(i=r)}return n*=n,t*=t,n?Math.max(t*i*p/n,n/(t*s*p)):Infinity}function i(e,t,n,r){var i=-1,s=e.length,o=n.x,a=n.y,f=t?u(e.area/t):0,l;if(t==n.dx){if(r||f>n.dy)f=n.dy;while(++in.dx)f=n.dx;while(++i50?n:s<-140?r:o<21?i:t)(e)}var t=d3.geo.albers(),n=d3.geo.albers().origin([-160,60]).parallels([55,65]),r=d3.geo.albers().origin([-160,20]).parallels([8,18]),i=d3.geo.albers().origin([-60,10]).parallels([8,18]);return e.scale=function(s){return arguments.length?(t.scale(s),n.scale(s*.6),r.scale(s),i.scale(s*1.5),e.translate(t.translate())):t.scale()},e.translate=function(s){if(!arguments.length)return t.translate();var o=t.scale()/1e3,u=s[0],a=s[1];return t.translate(s),n.translate([u-400*o,a+170*o]),r.translate([u-190*o,a+200*o]),i.translate([u+580*o,a+430*o]),e},e.scale(t.scale())},d3.geo.bonne=function(){function e(e){var u=e[0]*mo-r,a=e[1]*mo-i;if(s){var f=o+s-a,l=u*Math.cos(a)/f;u=f*Math.sin(l),a=f*Math.cos(l)-o}else u*=Math.cos(a),a*=-1;return[t*u+n[0],t*a+n[1]]}var t=200,n=[480,250],r,i,s,o;return e.invert=function(e){var i=(e[0]-n[0])/t,u=(e[1]-n[1])/t;if(s){var a=o+u,f=Math.sqrt(i*i+a*a);u=o+s-f,i=r+f*Math.atan2(i,a)/Math.cos(u)}else u*=-1,i/=Math.cos(u);return[i/mo,u/mo]},e.parallel=function(t){return arguments.length?(o=1/Math.tan(s=t*mo),e):s/mo},e.origin=function(t){return arguments.length?(r=t[0]*mo,i=t[1]*mo,e):[r/mo,i/mo]},e.scale=function( +n){return arguments.length?(t=+n,e):t},e.translate=function(t){return arguments.length?(n=[+t[0],+t[1]],e):n},e.origin([0,0]).parallel(45)},d3.geo.equirectangular=function(){function e(e){var r=e[0]/360,i=-e[1]/360;return[t*r+n[0],t*i+n[1]]}var t=500,n=[480,250];return e.invert=function(e){var r=(e[0]-n[0])/t,i=(e[1]-n[1])/t;return[360*r,-360*i]},e.scale=function(n){return arguments.length?(t=+n,e):t},e.translate=function(t){return arguments.length?(n=[+t[0],+t[1]],e):n},e},d3.geo.mercator=function(){function e(e){var r=e[0]/360,i=-(Math.log(Math.tan(Math.PI/4+e[1]*mo/2))/mo)/360;return[t*r+n[0],t*Math.max(-0.5,Math.min(.5,i))+n[1]]}var t=500,n=[480,250];return e.invert=function(e){var r=(e[0]-n[0])/t,i=(e[1]-n[1])/t;return[360*r,2*Math.atan(Math.exp(-360*i*mo))/mo-90]},e.scale=function(n){return arguments.length?(t=+n,e):t},e.translate=function(t){return arguments.length?(n=[+t[0],+t[1]],e):n},e},d3.geo.path=function(){function e(e,t){typeof s=="function"&&(o=zr(s.apply(this,arguments))),f(e);var n=a.length?a.join(""):null;return a=[],n}function t(e){return u(e).join(",")}function n(e){var t=i(e[0]),n=0,r=e.length;while(++n0){a.push("M");while(++o0){a.push("M");while(++lr&&(r=e),si&&(i=s)}),[[t,n],[r,i]]};var go={Feature:Xr,FeatureCollection:Vr,GeometryCollection:$r,LineString:Jr,MultiLineString:Kr,MultiPoint:Jr,MultiPolygon:Qr,Point:Gr,Polygon:Yr};d3.geo.circle=function(){function e(){}function t(e){return a.distance(e)=l*l+c*c?r[s].index=-1:(r[h].index=-1,d=r[s].angle,h=s,p=o)):(d=r[s].angle,h=s,p=o);i.push(u);for(s=0,o=0;s<2;++o)r[o].index!==-1&&(i.push(r[o].index),s++);v=i.length;for(;o=0?(n=e.ep.r,r=e.ep.l):(n=e.ep.l,r=e.ep.r),e.a===1?(o=n?n.y:-1e6,i=e.c-e.b*o,u=r?r.y:1e6,s=e.c-e.b*u):(i=n?n.x:-1e6,o=e.c-e.a*i,s=r?r.x:1e6,u=e.c-e.a*s);var a=[i,o],f=[s,u];t[e.region.l.index].push(a,f),t[e.region.r.index].push(a,f)}),t.map(function(t,n){var r=e[n][0],i=e[n][1];return t.forEach(function(e){e.angle=Math.atan2(e[0]-r,e[1]-i)}),t.sort(function(e,t){return e.angle-t.angle}).filter(function(e,n){return!n||e.angle-t[n-1].angle>1e-10})})};var wo={l:"r",r:"l"};d3.geom.delaunay=function(e){var t=e.map(function(){return[]}),n=[];return ui(e,function(n){t[n.region.l.index].push(e[n.region.r.index])}),t.forEach(function(t,r){var i=e[r],s=i[0],o=i[1];t.forEach(function(e){e.angle=Math.atan2(e[0]-s,e[1]-o)}),t.sort(function(e,t){return e.angle-t.angle});for(var u=0,a=t.length-1;u=u,l=t.y>=a,c=(l<<1)+f;e.leaf=!1,e=e.nodes[c]||(e.nodes[c]=ai()),f?n=u:i=u,l?r=a:o=a,s(e,t,n,r,i,o)}var u,a=-1,f=e.length;f&&isNaN(e[0].x)&&(e=e.map(li));if(arguments.length<5)if(arguments.length===3)i=r=n,n=t;else{t=n=Infinity,r=i=-Infinity;while(++ar&&(r=u.x),u.y>i&&(i=u.y);var l=r-t,c=i-n;l>c?i=n+l:r=t+c}var h=ai();return h.add=function(e){s(h,e,t,n,r,i)},h.visit=function(e){fi(e,h,t,n,r,i)},e.forEach(h.add),h},d3.time={};var Eo=Date,So=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];ci.prototype={getDate:function(){return this._.getUTCDate()},getDay:function(){return this._.getUTCDay()},getFullYear:function(){return this._.getUTCFullYear()},getHours:function(){return this._.getUTCHours()},getMilliseconds:function(){return this._.getUTCMilliseconds()},getMinutes:function(){return this._.getUTCMinutes()},getMonth:function(){return this._.getUTCMonth()},getSeconds:function(){return this._.getUTCSeconds()},getTime:function(){return this._.getTime()},getTimezoneOffset:function(){return 0},valueOf:function(){return this._.valueOf()},setDate:function(){xo.setUTCDate.apply(this._,arguments)},setDay:function(){xo.setUTCDay.apply(this._,arguments)},setFullYear:function(){xo.setUTCFullYear.apply(this._,arguments)},setHours:function(){xo.setUTCHours.apply(this._,arguments)},setMilliseconds:function(){xo.setUTCMilliseconds.apply(this._,arguments)},setMinutes:function(){xo.setUTCMinutes.apply(this._,arguments)},setMonth:function(){xo.setUTCMonth.apply(this._,arguments)},setSeconds:function(){xo.setUTCSeconds.apply(this._,arguments)},setTime:function(){xo.setTime.apply(this._,arguments)}};var xo=Date.prototype,To="%a %b %e %H:%M:%S %Y",No="%m/%d/%y",Co="%H:%M:%S",ko=So,Lo=ko.map(hi),Ao=["January","February","March","April","May","June","July","August","September","October","November","December"],Oo=Ao.map(hi);d3.time.format=function(e){function t(t){var r=[],i=-1,s=0,o,u;while(++i=12?"PM":"AM"},S:function(e){return Mo(e.getSeconds())},U:function(e){return Mo(d3.time.sundayOfYear(e))},w:function(e){return e.getDay()},W:function(e){return Mo(d3.time.mondayOfYear(e))},x:d3.time.format(No),X:d3.time.format(Co),y:function(e){return Mo(e.getFullYear()%100)},Y:function(e){return Do(e.getFullYear()%1e4)},Z:Di,"%":function(e){return"%"}},Uo={a:mi,A:gi,b:yi,B:bi,c:wi,d:ki,e:ki,H:Li,I:Li,L:Mi,m:Ci,M:Ai,p:_i,S:Oi,x:Ei,X:Si,y:Ti,Y:xi},zo=/^\s*\d+/,Wo=d3.map({am:0,pm:1});d3.time.format.utc=function(e){function t(e){try{Eo=ci;var t=new Eo;return t._=e,n(t)}finally{Eo=Date}}var n=d3.time.format(e);return t.parse=function(e){try{Eo=ci;var t=n.parse(e);return t&&t._}finally{Eo=Date}},t.toString=n.toString,t};var Xo=d3.time.format.utc("%Y-%m-%dT%H:%M:%S.%LZ");d3.time.format.iso=Date.prototype.toISOString?Pi:Xo,Pi.parse=function(e){var t=new Date(e);return isNaN(t)?null:t},Pi.toString=Xo.toString,d3.time.second=Hi(function(e){return new Eo(Math.floor(e/1e3)*1e3)},function(e,t){e.setTime(e.getTime()+Math.floor(t)*1e3)},function(e){return e.getSeconds()}),d3.time.seconds=d3.time.second.range,d3.time.seconds.utc=d3.time.second.utc.range,d3.time.minute=Hi(function(e){return new Eo(Math.floor(e/6e4)*6e4)},function(e,t){e.setTime(e.getTime()+Math.floor(t)*6e4)},function(e){return e.getMinutes()}),d3.time.minutes=d3.time.minute.range,d3.time.minutes.utc=d3.time.minute.utc.range,d3.time.hour=Hi(function(e){var t=e.getTimezoneOffset()/60;return new Eo((Math.floor(e/36e5-t)+t)*36e5)},function(e,t){e.setTime(e.getTime()+Math.floor(t)*36e5)},function(e){return e.getHours()}),d3.time.hours=d3.time.hour.range,d3.time.hours.utc=d3.time.hour.utc.range,d3.time.day=Hi(function(e){var t=new Eo(1970,0);return t.setFullYear(e.getFullYear(),e.getMonth(),e.getDate()),t},function(e,t){e.setDate(e.getDate()+t)},function(e){return e.getDate()-1}),d3.time.days=d3.time.day.range,d3.time.days.utc=d3.time.day.utc.range,d3.time.dayOfYear=function(e){var t=d3.time.year(e);return Math.floor((e-t-(e.getTimezoneOffset()-t.getTimezoneOffset())*6e4)/864e5)},So.forEach(function(e,t){e=e.toLowerCase(),t=7-t;var n=d3.time[e]=Hi(function(e){return(e=d3.time.day(e)).setDate(e.getDate()-(e.getDay()+t)%7),e},function(e,t){e.setDate(e.getDate()+Math.floor(t)*7)},function(e){var n=d3.time.year(e).getDay();return Math.floor((d3.time.dayOfYear(e)+(n+t)%7)/7)-(n!==t)});d3.time[e+"s"]=n.range,d3.time[e+"s"].utc=n.utc.range,d3.time[e+"OfYear"]=function(e){var n=d3.time.year(e).getDay();return Math.floor((d3.time.dayOfYear(e)+(n+t)%7)/7)}}),d3.time.week=d3.time.sunday,d3.time.weeks=d3.time.sunday.range,d3.time.weeks.utc=d3.time.sunday.utc.range,d3.time.weekOfYear=d3.time.sundayOfYear,d3.time.month=Hi(function(e){return e=d3.time.day(e),e.setDate(1),e},function(e,t){e.setMonth(e.getMonth()+t)},function(e){return e.getMonth()}),d3.time.months=d3.time.month.range,d3.time.months.utc=d3.time.month.utc.range,d3.time.year=Hi(function(e){return e=d3.time.day(e),e.setMonth(0,1),e},function(e,t){e.setFullYear(e.getFullYear()+t)},function(e){return e.getFullYear()}),d3.time.years=d3.time.year.range,d3.time.years.utc=d3.time.year.utc.range;var Vo=[1e3,5e3,15e3,3e4,6e4,3e5,9e5,18e5,36e5,108e5,216e5,432e5,864e5,1728e5,6048e5,2592e6,7776e6,31536e6],$o=[[d3.time.second,1],[d3.time.second,5],[d3.time.second,15],[d3.time.second,30],[d3.time.minute,1],[d3.time.minute,5],[d3.time.minute,15],[d3.time.minute,30],[d3.time.hour,1],[d3.time.hour,3],[d3.time.hour,6],[d3.time.hour,12],[d3.time.day,1],[d3.time.day,2],[d3.time.week,1],[d3.time.month,1],[d3.time.month,3],[d3.time.year,1]],Jo=[[d3.time.format("%Y"),function(e){return!0}],[d3.time.format("%B"),function(e){return e.getMonth()}],[d3.time.format("%b %d"),function(e){return e.getDate()!=1}],[d3.time.format("%a %d"),function(e){return e.getDay()&&e.getDate()!=1}],[d3.time.format("%I %p"),function(e){return e.getHours()}],[d3.time.format("%I:%M"),function(e){return e.getMinutes()}],[d3.time.format(":%S"),function(e){return e.getSeconds()}],[d3.time.format(".%L"),function(e){return e.getMilliseconds()}]],Ko=d3.scale.linear(),Qo=qi(Jo);$o.year=function(e,t){return Ko.domain(e.map(Ui)).ticks(t).map(Ri)},d3.time.scale=function(){return ji(d3.scale.linear(),$o,Qo)};var Go=$o.map(function(e){return[e[0].utc,e[1]]}),Yo=[[d3.time.format.utc("%Y"),function(e){return!0}],[d3.time.format.utc("%B"),function(e){return e.getUTCMonth()}],[d3.time.format.utc("%b %d"),function(e){return e.getUTCDate()!=1}],[d3.time.format.utc("%a %d"),function(e){return e.getUTCDay()&&e.getUTCDate()!=1}],[d3.time.format.utc("%I %p"),function(e){return e.getUTCHours()}],[d3.time.format.utc("%I:%M"),function(e){return e.getUTCMinutes()}],[d3.time.format.utc(":%S"),function(e){return e.getUTCSeconds()}],[d3.time.format.utc(".%L"),function(e){return e.getUTCMilliseconds()}]],Zo=qi(Yo);Go.year=function(e,t){return Ko.domain(e.map(Wi)).ticks(t).map(zi)},d3.time.scale.utc=function(){return ji(d3.scale.linear(),Go,Zo)}})(); diff --git a/plugin/teksi_wastewater/svgprofile/dojo.js b/plugin/teksi_wastewater/svgprofile/dojo.js new file mode 100644 index 000000000..2f475406d --- /dev/null +++ b/plugin/teksi_wastewater/svgprofile/dojo.js @@ -0,0 +1,15 @@ +/* + Copyright (c) 2004-2012, The Dojo Foundation All Rights Reserved. + Available via Academic Free License >= 2.1 OR the modified BSD license. + see: http://dojotoolkit.org/license for details +*/ + +/* + This is an optimized version of Dojo, built for deployment and not for + development. To get sources and documentation, please visit: + + http://dojotoolkit.org +*/ + +//>>built +(function(_1,_2){var _3=function(){},_4=function(it){for(var p in it){return 0;}return 1;},_5={}.toString,_6=function(it){return _5.call(it)=="[object Function]";},_7=function(it){return _5.call(it)=="[object String]";},_8=function(it){return _5.call(it)=="[object Array]";},_9=function(_a,_b){if(_a){for(var i=0;i<_a.length;){_b(_a[i++]);}}},_c=function(_d,_e){for(var p in _e){_d[p]=_e[p];}return _d;},_f=function(_10,_11){return _c(new Error(_10),{src:"dojoLoader",info:_11});},_12=1,uid=function(){return "_"+_12++;},req=function(_13,_14,_15){return _16(_13,_14,_15,0,req);},_17=this,doc=_17.document,_18=doc&&doc.createElement("DiV"),has=req.has=function(_19){return _6(_1a[_19])?(_1a[_19]=_1a[_19](_17,doc,_18)):_1a[_19];},_1a=has.cache=_2.hasCache;has.add=function(_1b,_1c,now,_1d){(_1a[_1b]===undefined||_1d)&&(_1a[_1b]=_1c);return now&&has(_1b);};0&&has.add("host-node",_1.has&&"host-node" in _1.has?_1.has["host-node"]:(typeof process=="object"&&process.versions&&process.versions.node&&process.versions.v8));if(0){require("./_base/configNode.js").config(_2);_2.loaderPatch.nodeRequire=require;}0&&has.add("host-rhino",_1.has&&"host-rhino" in _1.has?_1.has["host-rhino"]:(typeof load=="function"&&(typeof Packages=="function"||typeof Packages=="object")));if(0){for(var _1e=_1.baseUrl||".",arg,_1f=this.arguments,i=0;i<_1f.length;){arg=(_1f[i++]+"").split("=");if(arg[0]=="baseUrl"){_1e=arg[1];break;}}load(_1e+"/_base/configRhino.js");rhinoDojoConfig(_2,_1e,_1f);}for(var p in _1.has){has.add(p,_1.has[p],0,1);}var _20=1,_21=2,_22=3,_23=4,_24=5;if(0){_20="requested";_21="arrived";_22="not-a-module";_23="executing";_24="executed";}var _25=0,_26="sync",xd="xd",_27=[],_28=0,_29=_3,_2a=_3,_2b;if(1){req.isXdUrl=_3;req.initSyncLoader=function(_2c,_2d,_2e){if(!_28){_28=_2c;_29=_2d;_2a=_2e;}return {sync:_26,requested:_20,arrived:_21,nonmodule:_22,executing:_23,executed:_24,syncExecStack:_27,modules:_2f,execQ:_30,getModule:_31,injectModule:_32,setArrived:_33,signal:_34,finishExec:_35,execModule:_36,dojoRequirePlugin:_28,getLegacyMode:function(){return _25;},guardCheckComplete:_37};};if(1){var _38=location.protocol,_39=location.host;req.isXdUrl=function(url){if(/^\./.test(url)){return false;}if(/^\/\//.test(url)){return true;}var _3a=url.match(/^([^\/\:]+\:)\/+([^\/]+)/);return _3a&&(_3a[1]!=_38||(_39&&_3a[2]!=_39));};1||has.add("dojo-xhr-factory",1);has.add("dojo-force-activex-xhr",1&&!doc.addEventListener&&window.location.protocol=="file:");has.add("native-xhr",typeof XMLHttpRequest!="undefined");if(has("native-xhr")&&!has("dojo-force-activex-xhr")){_2b=function(){return new XMLHttpRequest();};}else{for(var _3b=["Msxml2.XMLHTTP","Microsoft.XMLHTTP","Msxml2.XMLHTTP.4.0"],_3c,i=0;i<3;){try{_3c=_3b[i++];if(new ActiveXObject(_3c)){break;}}catch(e){}}_2b=function(){return new ActiveXObject(_3c);};}req.getXhr=_2b;has.add("dojo-gettext-api",1);req.getText=function(url,_3d,_3e){var xhr=_2b();xhr.open("GET",_3f(url),false);xhr.send(null);if(xhr.status==200||(!location.host&&!xhr.status)){if(_3e){_3e(xhr.responseText,_3d);}}else{throw _f("xhrFailed",xhr.status);}return xhr.responseText;};}}else{req.async=1;}var _40=new Function("return eval(arguments[0]);");req.eval=function(_41,_42){return _40(_41+"\r\n////@ sourceURL="+_42);};var _43={},_44="error",_34=req.signal=function(_45,_46){var _47=_43[_45];_9(_47&&_47.slice(0),function(_48){_48.apply(null,_8(_46)?_46:[_46]);});},on=req.on=function(_49,_4a){var _4b=_43[_49]||(_43[_49]=[]);_4b.push(_4a);return {remove:function(){for(var i=0;i<_4b.length;i++){if(_4b[i]===_4a){_4b.splice(i,1);return;}}}};};var _4c=[],_4d={},_4e=[],_4f={},map=req.map={},_50=[],_2f={},_51="",_52={},_53="url:",_54={},_55={};if(1){var _56=function(_57){var p,_58,_59,now,m;for(p in _54){_58=_54[p];_59=p.match(/^url\:(.+)/);if(_59){_52[_53+_5a(_59[1],_57)]=_58;}else{if(p=="*now"){now=_58;}else{if(p!="*noref"){m=_5b(p,_57);_52[m.mid]=_52[_53+m.url]=_58;}}}}if(now){now(_5c(_57));}_54={};},_5d=function(s){return s.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g,function(c){return "\\"+c;});},_5e=function(map,_5f){_5f.splice(0,_5f.length);for(var p in map){_5f.push([p,map[p],new RegExp("^"+_5d(p)+"(/|$)"),p.length]);}_5f.sort(function(lhs,rhs){return rhs[3]-lhs[3];});return _5f;},_60=function(_61){var _62=_61.name;if(!_62){_62=_61;_61={name:_62};}_61=_c({main:"main"},_61);_61.location=_61.location?_61.location:_62;if(_61.packageMap){map[_62]=_61.packageMap;}if(!_61.main.indexOf("./")){_61.main=_61.main.substring(2);}_4f[_62]=_61;},_63=[],_64=function(_65,_66,_67){for(var p in _65){if(p=="waitSeconds"){req.waitms=(_65[p]||0)*1000;}if(p=="cacheBust"){_51=_65[p]?(_7(_65[p])?_65[p]:(new Date()).getTime()+""):"";}if(p=="baseUrl"||p=="combo"){req[p]=_65[p];}if(1&&p=="async"){var _68=_65[p];req.legacyMode=_25=(_7(_68)&&/sync|legacyAsync/.test(_68)?_68:(!_68?_26:false));req.async=!_25;}if(_65[p]!==_1a){req.rawConfig[p]=_65[p];p!="has"&&has.add("config-"+p,_65[p],0,_66);}}if(!req.baseUrl){req.baseUrl="./";}if(!/\/$/.test(req.baseUrl)){req.baseUrl+="/";}for(p in _65.has){has.add(p,_65.has[p],0,_66);}_9(_65.packages,_60);for(_1e in _65.packagePaths){_9(_65.packagePaths[_1e],function(_69){var _6a=_1e+"/"+_69;if(_7(_69)){_69={name:_69};}_69.location=_6a;_60(_69);});}_5e(_c(map,_65.map),_50);_9(_50,function(_6b){_6b[1]=_5e(_6b[1],[]);if(_6b[0]=="*"){_50.star=_6b[1];}});_5e(_c(_4d,_65.paths),_4e);_9(_65.aliases,function(_6c){if(_7(_6c[0])){_6c[0]=new RegExp("^"+_5d(_6c[0])+"$");}_4c.push(_6c);});if(_66){_63.push({config:_65.config});}else{for(p in _65.config){var _6d=_31(p,_67);_6d.config=_c(_6d.config||{},_65.config[p]);}}if(_65.cache){_56();_54=_65.cache;if(_65.cache["*noref"]){_56();}}_34("config",[_65,req.rawConfig]);};if(has("dojo-cdn")||1){var _6e=doc.getElementsByTagName("script"),i=0,_6f,_70,src,_71;while(i<_6e.length){_6f=_6e[i++];if((src=_6f.getAttribute("src"))&&(_71=src.match(/(((.*)\/)|^)dojo\.js(\W|$)/i))){_70=_71[3]||"";_2.baseUrl=_2.baseUrl||_70;src=(_6f.getAttribute("data-dojo-config")||_6f.getAttribute("djConfig"));if(src){_55=req.eval("({ "+src+" })","data-dojo-config");}if(0){var _72=_6f.getAttribute("data-main");if(_72){_55.deps=_55.deps||[_72];}}break;}}}if(0){try{if(window.parent!=window&&window.parent.require){var doh=window.parent.require("doh");doh&&_c(_55,doh.testConfig);}}catch(e){}}req.rawConfig={};_64(_2,1);if(has("dojo-cdn")){_4f.dojo.location=_70;if(_70){_70+="/";}_4f.dijit.location=_70+"../dijit/";_4f.dojox.location=_70+"../dojox/";}_64(_1,1);_64(_55,1);}else{_4d=_2.paths;_4e=_2.pathsMapProg;_4f=_2.packs;_4c=_2.aliases;_50=_2.mapProgs;_2f=_2.modules;_52=_2.cache;_51=_2.cacheBust;req.rawConfig=_2;}if(0){req.combo=req.combo||{add:_3};var _73=0,_74=[],_75=null;}var _76=function(_77){_37(function(){_9(_77.deps,_32);if(0&&_73&&!_75){_75=setTimeout(function(){_73=0;_75=null;req.combo.done(function(_78,url){var _79=function(){_7a(0,_78);_7b();};_74.push(_78);_7c=_78;req.injectUrl(url,_79,_78);_7c=0;},req);},0);}});},_16=function(a1,a2,a3,_7d,_7e){var _7f,_80;if(_7(a1)){_7f=_31(a1,_7d,true);if(_7f&&_7f.executed){return _7f.result;}throw _f("undefinedModule",a1);}if(!_8(a1)){_64(a1,0,_7d);a1=a2;a2=a3;}if(_8(a1)){if(!a1.length){a2&&a2();}else{_80="require*"+uid();for(var mid,_81=[],i=0;i_ab){_ac=_6(_ad[1])?mid.replace(_ad[0],_ad[1]):_ad[1];}});if(_ac){return _9c(_ac,0,_9e,_9f,_a0,_a1,_a2,_a3);}_a8=_9f[mid];if(_a8){return _a3?_82(_a8.pid,_a8.mid,_a8.pack,_a8.url):_9f[mid];}}_a7=_94(mid,_a2);if(_a7){url=_a7[1]+mid.substring(_a7[3]);}else{if(pid){url=_a4.location+"/"+_a5;}else{if(has("config-tlmSiblingOfDojo")){url="../"+mid;}else{url=mid;}}}if(!(/(^\/)|(\:)/.test(url))){url=_a0+url;}url+=".js";return _82(pid,mid,_a4,_96(url));},_5b=function(mid,_af){return _9c(mid,_af,_4f,_2f,req.baseUrl,_50,_4e);},_b0=function(_b1,_b2,_b3){return _b1.normalize?_b1.normalize(_b2,function(mid){return _b4(mid,_b3);}):_b4(_b2,_b3);},_b5=0,_31=function(mid,_b6,_b7){var _b8,_b9,_ba,_bb;_b8=mid.match(/^(.+?)\!(.*)$/);if(_b8){_b9=_31(_b8[1],_b6,_b7);if(1&&_25==_26&&!_b9.executed){_32(_b9);if(_b9.injected===_21&&!_b9.executed){_37(function(){_36(_b9);});}if(_b9.executed){_bc(_b9);}else{_30.unshift(_b9);}}if(_b9.executed===_24&&!_b9.load){_bc(_b9);}if(_b9.load){_ba=_b0(_b9,_b8[2],_b6);mid=(_b9.mid+"!"+(_b9.dynamic?++_b5+"!":"")+_ba);}else{_ba=_b8[2];mid=_b9.mid+"!"+(++_b5)+"!waitingForPlugin";}_bb={plugin:_b9,mid:mid,req:_5c(_b6),prid:_ba};}else{_bb=_5b(mid,_b6);}return _2f[_bb.mid]||(!_b7&&(_2f[_bb.mid]=_bb));},_b4=req.toAbsMid=function(mid,_bd){return _5b(mid,_bd).mid;},_5a=req.toUrl=function(_be,_bf){var _c0=_5b(_be+"/x",_bf),url=_c0.url;return _3f(_c0.pid===0?_be:url.substring(0,url.length-5));},_c1={injected:_21,executed:_24,def:_22,result:_22},_c2=function(mid){return _2f[mid]=_c({mid:mid},_c1);},_c3=_c2("require"),_c4=_c2("exports"),_c5=_c2("module"),_c6=function(_c7,_c8){req.trace("loader-run-factory",[_c7.mid]);var _c9=_c7.def,_ca;1&&_27.unshift(_c7);if(has("config-dojo-loader-catches")){try{_ca=_6(_c9)?_c9.apply(null,_c8):_c9;}catch(e){_34(_44,_c7.result=_f("factoryThrew",[_c7,e]));}}else{_ca=_6(_c9)?_c9.apply(null,_c8):_c9;}_c7.result=_ca===undefined&&_c7.cjs?_c7.cjs.exports:_ca;1&&_27.shift(_c7);},_cb={},_cc=0,_bc=function(_cd){var _ce=_cd.result;_cd.dynamic=_ce.dynamic;_cd.normalize=_ce.normalize;_cd.load=_ce.load;return _cd;},_cf=function(_d0){var map={};_9(_d0.loadQ,function(_d1){var _d2=_b0(_d0,_d1.prid,_d1.req.module),mid=_d0.dynamic?_d1.mid.replace(/waitingForPlugin$/,_d2):(_d0.mid+"!"+_d2),_d3=_c(_c({},_d1),{mid:mid,prid:_d2,injected:0});if(!_2f[mid]){_e5(_2f[mid]=_d3);}map[_d1.mid]=_2f[mid];_33(_d1);delete _2f[_d1.mid];});_d0.loadQ=0;var _d4=function(_d5){for(var _d6,_d7=_d5.deps||[],i=0;i<_d7.length;i++){_d6=map[_d7[i].mid];if(_d6){_d7[i]=_d6;}}};for(var p in _2f){_d4(_2f[p]);}_9(_30,_d4);},_35=function(_d8){req.trace("loader-finish-exec",[_d8.mid]);_d8.executed=_24;_d8.defOrder=_cc++;1&&_9(_d8.provides,function(cb){cb();});if(_d8.loadQ){_bc(_d8);_cf(_d8);}for(i=0;i<_30.length;){if(_30[i]===_d8){_30.splice(i,1);}else{i++;}}if(/^require\*/.test(_d8.mid)){delete _2f[_d8.mid];}},_d9=[],_36=function(_da,_db){if(_da.executed===_23){req.trace("loader-circular-dependency",[_d9.concat(_da.mid).join("->")]);return (!_da.def||_db)?_cb:(_da.cjs&&_da.cjs.exports);}if(!_da.executed){if(!_da.def){return _cb;}var mid=_da.mid,_dc=_da.deps||[],arg,_dd,_de=[],i=0;if(0){_d9.push(mid);req.trace("loader-exec-module",["exec",_d9.length,mid]);}_da.executed=_23;while(i<_dc.length){arg=_dc[i++];_dd=((arg===_c3)?_5c(_da):((arg===_c4)?_da.cjs.exports:((arg===_c5)?_da.cjs:_36(arg,_db))));if(_dd===_cb){_da.executed=0;req.trace("loader-exec-module",["abort",mid]);0&&_d9.pop();return _cb;}_de.push(_dd);}_c6(_da,_de);_35(_da);0&&_d9.pop();}return _da.result;},_84=0,_37=function(_df){try{_84++;_df();}finally{_84--;}if(_93()){_34("idle",[]);}},_7b=function(){if(_84){return;}_37(function(){_29();for(var _e0,_e1,i=0;i<_30.length;){_e0=_cc;_e1=_30[i];_36(_e1);if(_e0!=_cc){_29();i=0;}else{i++;}}});};if(0){req.undef=function(_e2,_e3){var _e4=_31(_e2,_e3);_33(_e4);delete _2f[_e4.mid];};}if(1){if(has("dojo-loader-eval-hint-url")===undefined){has.add("dojo-loader-eval-hint-url",1);}var _3f=function(url){url+="";return url+(_51?((/\?/.test(url)?"&":"?")+_51):"");},_e5=function(_e6){var _e7=_e6.plugin;if(_e7.executed===_24&&!_e7.load){_bc(_e7);}var _e8=function(def){_e6.result=def;_33(_e6);_35(_e6);_7b();};if(_e7.load){_e7.load(_e6.prid,_e6.req,_e8);}else{if(_e7.loadQ){_e7.loadQ.push(_e6);}else{_e7.loadQ=[_e6];_30.unshift(_e7);_32(_e7);}}},_8a=0,_7c=0,_e9=0,_8b=function(_ea,_eb){if(has("config-stripStrict")){_ea=_ea.replace(/"use strict"/g,"");}_e9=1;if(has("config-dojo-loader-catches")){try{if(_ea===_8a){_8a.call(null);}else{req.eval(_ea,has("dojo-loader-eval-hint-url")?_eb.url:_eb.mid);}}catch(e){_34(_44,_f("evalModuleThrew",_eb));}}else{if(_ea===_8a){_8a.call(null);}else{req.eval(_ea,has("dojo-loader-eval-hint-url")?_eb.url:_eb.mid);}}_e9=0;},_32=function(_ec){var mid=_ec.mid,url=_ec.url;if(_ec.executed||_ec.injected||_8d[mid]||(_ec.url&&((_ec.pack&&_8d[_ec.url]===_ec.pack)||_8d[_ec.url]==1))){return;}_8e(_ec);if(0){var _ed=0;if(_ec.plugin&&_ec.plugin.isCombo){req.combo.add(_ec.plugin.mid,_ec.prid,0,req);_ed=1;}else{if(!_ec.plugin){_ed=req.combo.add(0,_ec.mid,_ec.url,req);}}if(_ed){_73=1;return;}}if(_ec.plugin){_e5(_ec);return;}var _ee=function(){_7a(_ec);if(_ec.injected!==_21){_33(_ec);_c(_ec,_c1);req.trace("loader-define-nonmodule",[_ec.url]);}if(1&&_25){!_27.length&&_7b();}else{_7b();}};_8a=_52[mid]||_52[_53+_ec.url];if(_8a){req.trace("loader-inject",["cache",_ec.mid,url]);_8b(_8a,_ec);_ee();return;}if(1&&_25){if(_ec.isXd){_25==_26&&(_25=xd);}else{if(_ec.isAmd&&_25!=_26){}else{var _ef=function(_f0){if(_25==_26){_27.unshift(_ec);_8b(_f0,_ec);_27.shift();_7a(_ec);if(!_ec.cjs){_33(_ec);_35(_ec);}if(_ec.finish){var _f1=mid+"*finish",_f2=_ec.finish;delete _ec.finish;def(_f1,["dojo",("dojo/require!"+_f2.join(",")).replace(/\./g,"/")],function(_f3){_9(_f2,function(mid){_f3.require(mid);});});_30.unshift(_31(_f1));}_ee();}else{_f0=_2a(_ec,_f0);if(_f0){_8b(_f0,_ec);_ee();}else{_7c=_ec;req.injectUrl(_3f(url),_ee,_ec);_7c=0;}}};req.trace("loader-inject",["xhr",_ec.mid,url,_25!=_26]);if(has("config-dojo-loader-catches")){try{req.getText(url,_25!=_26,_ef);}catch(e){_34(_44,_f("xhrInjectFailed",[_ec,e]));}}else{req.getText(url,_25!=_26,_ef);}return;}}}req.trace("loader-inject",["script",_ec.mid,url]);_7c=_ec;req.injectUrl(_3f(url),_ee,_ec);_7c=0;},_f4=function(_f5,_f6,def){req.trace("loader-define-module",[_f5.mid,_f6]);if(0&&_f5.plugin&&_f5.plugin.isCombo){_f5.result=_6(def)?def():def;_33(_f5);_35(_f5);return _f5;}var mid=_f5.mid;if(_f5.injected===_21){_34(_44,_f("multipleDefine",_f5));return _f5;}_c(_f5,{deps:_f6,def:def,cjs:{id:_f5.mid,uri:_f5.url,exports:(_f5.result={}),setExports:function(_f7){_f5.cjs.exports=_f7;},config:function(){return _f5.config;}}});for(var i=0;i<_f6.length;i++){_f6[i]=_31(_f6[i],_f5);}if(1&&_25&&!_8d[mid]){_76(_f5);_30.push(_f5);_7b();}_33(_f5);if(!_6(def)&&!_f6.length){_f5.result=def;_35(_f5);}return _f5;},_7a=function(_f8,_f9){var _fa=[],_fb,_fc;while(_8c.length){_fc=_8c.shift();_f9&&(_fc[0]=_f9.shift());_fb=(_fc[0]&&_31(_fc[0]))||_f8;_fa.push([_fb,_fc[1],_fc[2]]);}_56(_f8);_9(_fa,function(_fd){_76(_f4.apply(null,_fd));});};}var _fe=0,_92=_3,_90=_3;if(1){_92=function(){_fe&&clearTimeout(_fe);_fe=0;},_90=function(){_92();if(req.waitms){_fe=window.setTimeout(function(){_92();_34(_44,_f("timeout",_8d));},req.waitms);}};}if(1){has.add("ie-event-behavior",!!doc.attachEvent&&(typeof opera==="undefined"||opera.toString()!="[object Opera]"));}if(1&&(1||1)){var _ff=function(node,_100,_101,_102){if(!has("ie-event-behavior")){node.addEventListener(_100,_102,false);return function(){node.removeEventListener(_100,_102,false);};}else{node.attachEvent(_101,_102);return function(){node.detachEvent(_101,_102);};}},_103=_ff(window,"load","onload",function(){req.pageLoaded=1;doc.readyState!="complete"&&(doc.readyState="complete");_103();});if(1){var _104=doc.getElementsByTagName("script")[0],_105=_104.parentNode;req.injectUrl=function(url,_106,_107){var node=_107.node=doc.createElement("script"),_108=function(e){e=e||window.event;var node=e.target||e.srcElement;if(e.type==="load"||/complete|loaded/.test(node.readyState)){_109();_10a();_106&&_106();}},_109=_ff(node,"load","onreadystatechange",_108),_10a=_ff(node,"error","onerror",function(e){_109();_10a();_34(_44,_f("scriptError",[url,e]));});node.type="text/javascript";node.charset="utf-8";node.src=url;_105.insertBefore(node,_104);return node;};}}if(1){req.log=function(){try{for(var i=0;i0){_129._delayTimer=setTimeout(_12a,de);return _129;}_12a();return _129;},_play:function(_12b){var _12c=this;if(_12c._delayTimer){_12c._clearTimer();}_12c._startTime=new Date().valueOf();if(_12c._paused){_12c._startTime-=_12c.duration*_12c._percent;}_12c._active=true;_12c._paused=false;var _12d=_12c.curve.getValue(_12c._getStep());if(!_12c._percent){if(!_12c._startRepeatCount){_12c._startRepeatCount=_12c.repeat;}_12c._fire("onBegin",[_12d]);}_12c._fire("onPlay",[_12d]);_12c._cycle();return _12c;},pause:function(){var _12e=this;if(_12e._delayTimer){_12e._clearTimer();}_12e._stopTimer();if(!_12e._active){return _12e;}_12e._paused=true;_12e._fire("onPause",[_12e.curve.getValue(_12e._getStep())]);return _12e;},gotoPercent:function(_12f,_130){var _131=this;_131._stopTimer();_131._active=_131._paused=true;_131._percent=_12f;if(_130){_131.play();}return _131;},stop:function(_132){var _133=this;if(_133._delayTimer){_133._clearTimer();}if(!_133._timer){return _133;}_133._stopTimer();if(_132){_133._percent=1;}_133._fire("onStop",[_133.curve.getValue(_133._getStep())]);_133._active=_133._paused=false;return _133;},status:function(){if(this._active){return this._paused?"paused":"playing";}return "stopped";},_cycle:function(){var _134=this;if(_134._active){var curr=new Date().valueOf();var step=_134.duration===0?1:(curr-_134._startTime)/(_134.duration);if(step>=1){step=1;}_134._percent=step;if(_134.easing){step=_134.easing(step);}_134._fire("onAnimate",[_134.curve.getValue(step)]);if(_134._percent<1){_134._startTimer();}else{_134._active=false;if(_134.repeat>0){_134.repeat--;_134.play(null,true);}else{if(_134.repeat==-1){_134.play(null,true);}else{if(_134._startRepeatCount){_134.repeat=_134._startRepeatCount;_134._startRepeatCount=0;}}}_134._percent=0;_134._fire("onEnd",[_134.node]);!_134.repeat&&_134._stopTimer();}}return _134;},_clearTimer:function(){clearTimeout(this._delayTimer);delete this._delayTimer;}});var ctr=0,_135=null,_136={run:function(){}};lang.extend(_124,{_startTimer:function(){if(!this._timer){this._timer=_11e.connect(_136,"run",this,"_cycle");ctr++;}if(!_135){_135=setInterval(lang.hitch(_136,"run"),this.rate);}},_stopTimer:function(){if(this._timer){_11e.disconnect(this._timer);this._timer=null;ctr--;}if(ctr<=0){clearInterval(_135);_135=null;ctr=0;}}});var _137=has("ie")?function(node){var ns=node.style;if(!ns.width.length&&_11f.get(node,"width")=="auto"){ns.width="auto";}}:function(){};_121._fade=function(args){args.node=dom.byId(args.node);var _138=_120({properties:{}},args),_139=(_138.properties.opacity={});_139.start=!("start" in _138)?function(){return +_11f.get(_138.node,"opacity")||0;}:_138.start;_139.end=_138.end;var anim=_121.animateProperty(_138);_11e.connect(anim,"beforeBegin",lang.partial(_137,_138.node));return anim;};_121.fadeIn=function(args){return _121._fade(_120({end:1},args));};_121.fadeOut=function(args){return _121._fade(_120({end:0},args));};_121._defaultEasing=function(n){return 0.5+((Math.sin((n+1.5)*Math.PI))/2);};var _13a=function(_13b){this._properties=_13b;for(var p in _13b){var prop=_13b[p];if(prop.start instanceof _11d){prop.tempColor=new _11d();}}};_13a.prototype.getValue=function(r){var ret={};for(var p in this._properties){var prop=this._properties[p],_13c=prop.start;if(_13c instanceof _11d){ret[p]=_11d.blendColors(_13c,prop.end,r,prop.tempColor).toCss();}else{if(!lang.isArray(_13c)){ret[p]=((prop.end-_13c)*r)+_13c+(p!="opacity"?prop.units||"px":0);}}}return ret;};_121.animateProperty=function(args){var n=args.node=dom.byId(args.node);if(!args.easing){args.easing=dojo._defaultEasing;}var anim=new _124(args);_11e.connect(anim,"beforeBegin",anim,function(){var pm={};for(var p in this.properties){if(p=="width"||p=="height"){this.node.display="block";}var prop=this.properties[p];if(lang.isFunction(prop)){prop=prop(n);}prop=pm[p]=_120({},(lang.isObject(prop)?prop:{end:prop}));if(lang.isFunction(prop.start)){prop.start=prop.start(n);}if(lang.isFunction(prop.end)){prop.end=prop.end(n);}var _13d=(p.toLowerCase().indexOf("color")>=0);function _13e(node,p){var v={height:node.offsetHeight,width:node.offsetWidth}[p];if(v!==undefined){return v;}v=_11f.get(node,p);return (p=="opacity")?+v:(_13d?v:parseFloat(v));};if(!("end" in prop)){prop.end=_13e(n,p);}else{if(!("start" in prop)){prop.start=_13e(n,p);}}if(_13d){prop.start=new _11d(prop.start);prop.end=new _11d(prop.end);}else{prop.start=(p=="opacity")?+prop.start:parseFloat(prop.start);}}this.curve=new _13a(pm);});_11e.connect(anim,"onAnimate",lang.hitch(_11f,"set",anim.node));return anim;};_121.anim=function(node,_13f,_140,_141,_142,_143){return _121.animateProperty({node:node,duration:_140||_124.prototype.duration,properties:_13f,easing:_141,onEnd:_142}).play(_143||0);};if(1){_120(dojo,_121);dojo._Animation=_124;}return _121;});},"dojo/dom-form":function(){define(["./_base/lang","./dom","./io-query","./json"],function(lang,dom,ioq,json){function _144(obj,name,_145){if(_145===null){return;}var val=obj[name];if(typeof val=="string"){obj[name]=[val,_145];}else{if(lang.isArray(val)){val.push(_145);}else{obj[name]=_145;}}};var _146="file|submit|image|reset|button";var form={fieldToObject:function fieldToObject(_147){var ret=null;_147=dom.byId(_147);if(_147){var _148=_147.name,type=(_147.type||"").toLowerCase();if(_148&&type&&!_147.disabled){if(type=="radio"||type=="checkbox"){if(_147.checked){ret=_147.value;}}else{if(_147.multiple){ret=[];var _149=[_147.firstChild];while(_149.length){for(var node=_149.pop();node;node=node.nextSibling){if(node.nodeType==1&&node.tagName.toLowerCase()=="option"){if(node.selected){ret.push(node.value);}}else{if(node.nextSibling){_149.push(node.nextSibling);}if(node.firstChild){_149.push(node.firstChild);}break;}}}}else{ret=_147.value;}}}}return ret;},toObject:function formToObject(_14a){var ret={},_14b=dom.byId(_14a).elements;for(var i=0,l=_14b.length;i=0){var mid=_18c.replace(/\./g,"/")+"_"+loc;_18a++;_190(mid,function(_197){for(var p in _197){_15d[_150.toAbsMid(p)+"/"+loc]=_197[p];}--_18a;while(!_18a&&_18b.length){load.apply(null,_18b.shift());}});return true;}return false;});};_195();_151.forEach(dojo.config.extraLocale,_195);},_177=function(id,_198,load){if(_18a){_18b.push([id,_198,load]);}return _18a;},_184=function(){};}if(1){var _199={},_19a=new Function("__bundle","__checkForLegacyModules","__mid","__amdValue","var define = function(mid, factory){define.called = 1; __amdValue.result = factory || mid;},"+"\t require = function(){define.called = 1;};"+"try{"+"define.called = 0;"+"eval(__bundle);"+"if(define.called==1)"+"return __amdValue;"+"if((__checkForLegacyModules = __checkForLegacyModules(__mid)))"+"return __checkForLegacyModules;"+"}catch(e){}"+"try{"+"return eval('('+__bundle+')');"+"}catch(e){"+"return e;"+"}"),_19b=function(deps,_19c,_19d){var _19e=[];_151.forEach(deps,function(mid){var url=_19d.toUrl(mid+".js");function load(text){var _19f=_19a(text,_184,mid,_199);if(_19f===_199){_19e.push(_15d[url]=_199.result);}else{if(_19f instanceof Error){console.error("failed to evaluate i18n bundle; url="+url,_19f);_19f={};}_19e.push(_15d[url]=(/nls\/[^\/]+\/[^\/]+$/.test(url)?_19f:{root:_19f,_v1x:1}));}};if(_15d[url]){_19e.push(_15d[url]);}else{var _1a0=_19d.syncLoadNls(mid);if(_1a0){_19e.push(_1a0);}else{if(!xhr){try{_19d.getText(url,true,load);}catch(e){_19e.push(_15d[url]={});}}else{xhr.get({url:url,sync:true,load:load,error:function(){_19e.push(_15d[url]={});}});}}}});_19c&&_19c.apply(null,_19e);};_184=function(_1a1){for(var _1a2,_1a3=_1a1.split("/"),_1a4=dojo.global[_1a3[0]],i=1;_1a4&&i<_1a3.length-1;_1a4=_1a4[_1a3[i++]]){}if(_1a4){_1a2=_1a4[_1a3[i]];if(!_1a2){_1a2=_1a4[_1a3[i].replace(/-/g,"_")];}if(_1a2){_15d[_1a1]=_1a2;}}return _1a2;};_154.getLocalization=function(_1a5,_1a6,_1a7){var _1a8,_1a9=_15e(_1a5,_1a6,_1a7);load(_1a9,(!isXd(_1a9,_150)?function(deps,_1aa){_19b(deps,_1aa,_150);}:_150),function(_1ab){_1a8=_1ab;});return _1a8;};if(has("dojo-unit-tests")){_185.push(function(doh){doh.register("tests.i18n.unit",function(t){var _1ac;_1ac=_19a("{prop:1}",_184,"nonsense",_199);t.is({prop:1},_1ac);t.is(undefined,_1ac[1]);_1ac=_19a("({prop:1})",_184,"nonsense",_199);t.is({prop:1},_1ac);t.is(undefined,_1ac[1]);_1ac=_19a("{'prop-x':1}",_184,"nonsense",_199);t.is({"prop-x":1},_1ac);t.is(undefined,_1ac[1]);_1ac=_19a("({'prop-x':1})",_184,"nonsense",_199);t.is({"prop-x":1},_1ac);t.is(undefined,_1ac[1]);_1ac=_19a("define({'prop-x':1})",_184,"nonsense",_199);t.is(_199,_1ac);t.is({"prop-x":1},_199.result);_1ac=_19a("define('some/module', {'prop-x':1})",_184,"nonsense",_199);t.is(_199,_1ac);t.is({"prop-x":1},_199.result);_1ac=_19a("this is total nonsense and should throw an error",_184,"nonsense",_199);t.is(_1ac instanceof Error,true);});});}}return lang.mixin(_154,{dynamic:true,normalize:_16f,load:load,cache:_15d});});},"dojo/promise/tracer":function(){define(["../_base/lang","./Promise","../Evented"],function(lang,_1ad,_1ae){"use strict";var _1af=new _1ae;var emit=_1af.emit;_1af.emit=null;function _1b0(args){setTimeout(function(){emit.apply(_1af,args);},0);};_1ad.prototype.trace=function(){var args=lang._toArray(arguments);this.then(function(_1b1){_1b0(["resolved",_1b1].concat(args));},function(_1b2){_1b0(["rejected",_1b2].concat(args));},function(_1b3){_1b0(["progress",_1b3].concat(args));});return this;};_1ad.prototype.traceRejected=function(){var args=lang._toArray(arguments);this.otherwise(function(_1b4){_1b0(["rejected",_1b4].concat(args));});return this;};return _1af;});},"dojo/errors/RequestError":function(){define(["./create"],function(_1b5){return _1b5("RequestError",function(_1b6,_1b7){this.response=_1b7;});});},"dojo/_base/html":function(){define("dojo/_base/html",["./kernel","../dom","../dom-style","../dom-attr","../dom-prop","../dom-class","../dom-construct","../dom-geometry"],function(dojo,dom,_1b8,attr,prop,cls,ctr,geom){dojo.byId=dom.byId;dojo.isDescendant=dom.isDescendant;dojo.setSelectable=dom.setSelectable;dojo.getAttr=attr.get;dojo.setAttr=attr.set;dojo.hasAttr=attr.has;dojo.removeAttr=attr.remove;dojo.getNodeProp=attr.getNodeProp;dojo.attr=function(node,name,_1b9){if(arguments.length==2){return attr[typeof name=="string"?"get":"set"](node,name);}return attr.set(node,name,_1b9);};dojo.hasClass=cls.contains;dojo.addClass=cls.add;dojo.removeClass=cls.remove;dojo.toggleClass=cls.toggle;dojo.replaceClass=cls.replace;dojo._toDom=dojo.toDom=ctr.toDom;dojo.place=ctr.place;dojo.create=ctr.create;dojo.empty=function(node){ctr.empty(node);};dojo._destroyElement=dojo.destroy=function(node){ctr.destroy(node);};dojo._getPadExtents=dojo.getPadExtents=geom.getPadExtents;dojo._getBorderExtents=dojo.getBorderExtents=geom.getBorderExtents;dojo._getPadBorderExtents=dojo.getPadBorderExtents=geom.getPadBorderExtents;dojo._getMarginExtents=dojo.getMarginExtents=geom.getMarginExtents;dojo._getMarginSize=dojo.getMarginSize=geom.getMarginSize;dojo._getMarginBox=dojo.getMarginBox=geom.getMarginBox;dojo.setMarginBox=geom.setMarginBox;dojo._getContentBox=dojo.getContentBox=geom.getContentBox;dojo.setContentSize=geom.setContentSize;dojo._isBodyLtr=dojo.isBodyLtr=geom.isBodyLtr;dojo._docScroll=dojo.docScroll=geom.docScroll;dojo._getIeDocumentElementOffset=dojo.getIeDocumentElementOffset=geom.getIeDocumentElementOffset;dojo._fixIeBiDiScrollLeft=dojo.fixIeBiDiScrollLeft=geom.fixIeBiDiScrollLeft;dojo.position=geom.position;dojo.marginBox=function marginBox(node,box){return box?geom.setMarginBox(node,box):geom.getMarginBox(node);};dojo.contentBox=function contentBox(node,box){return box?geom.setContentSize(node,box):geom.getContentBox(node);};dojo.coords=function(node,_1ba){dojo.deprecated("dojo.coords()","Use dojo.position() or dojo.marginBox().");node=dom.byId(node);var s=_1b8.getComputedStyle(node),mb=geom.getMarginBox(node,s);var abs=geom.position(node,_1ba);mb.x=abs.x;mb.y=abs.y;return mb;};dojo.getProp=prop.get;dojo.setProp=prop.set;dojo.prop=function(node,name,_1bb){if(arguments.length==2){return prop[typeof name=="string"?"get":"set"](node,name);}return prop.set(node,name,_1bb);};dojo.getStyle=_1b8.get;dojo.setStyle=_1b8.set;dojo.getComputedStyle=_1b8.getComputedStyle;dojo.__toPixelValue=dojo.toPixelValue=_1b8.toPixelValue;dojo.style=function(node,name,_1bc){switch(arguments.length){case 1:return _1b8.get(node);case 2:return _1b8[typeof name=="string"?"get":"set"](node,name);}return _1b8.set(node,name,_1bc);};return dojo;});},"dojo/_base/kernel":function(){define(["../has","./config","require","module"],function(has,_1bd,_1be,_1bf){var i,p,_1c0={},_1c1={},dojo={config:_1bd,global:this,dijit:_1c0,dojox:_1c1};var _1c2={dojo:["dojo",dojo],dijit:["dijit",_1c0],dojox:["dojox",_1c1]},_1c3=(_1be.map&&_1be.map[_1bf.id.match(/[^\/]+/)[0]]),item;for(p in _1c3){if(_1c2[p]){_1c2[p][0]=_1c3[p];}else{_1c2[p]=[_1c3[p],{}];}}for(p in _1c2){item=_1c2[p];item[1]._scopeName=item[0];if(!_1bd.noGlobals){this[item[0]]=item[1];}}dojo.scopeMap=_1c2;dojo.baseUrl=dojo.config.baseUrl=_1be.baseUrl;dojo.isAsync=!1||_1be.async;dojo.locale=_1bd.locale;var rev="$Rev: 29801 $".match(/\d+/);dojo.version={major:1,minor:8,patch:1,flag:"",revision:rev?+rev[0]:NaN,toString:function(){var v=dojo.version;return v.major+"."+v.minor+"."+v.patch+v.flag+" ("+v.revision+")";}};1||has.add("extend-dojo",1);(Function("d","d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);if(0){dojo.exit=function(_1c4){quit(_1c4);};}else{dojo.exit=function(){};}1||has.add("dojo-guarantee-console",1);if(1){typeof console!="undefined"||(console={});var cn=["assert","count","debug","dir","dirxml","error","group","groupEnd","info","profile","profileEnd","time","timeEnd","trace","warn","log"];var tn;i=0;while((tn=cn[i++])){if(!console[tn]){(function(){var tcn=tn+"";console[tcn]=("log" in console)?function(){var a=Array.apply({},arguments);a.unshift(tcn+":");console["log"](a.join(" "));}:function(){};console[tcn]._fake=true;})();}}}has.add("dojo-debug-messages",!!_1bd.isDebug);dojo.deprecated=dojo.experimental=function(){};if(has("dojo-debug-messages")){dojo.deprecated=function(_1c5,_1c6,_1c7){var _1c8="DEPRECATED: "+_1c5;if(_1c6){_1c8+=" "+_1c6;}if(_1c7){_1c8+=" -- will be removed in version: "+_1c7;}console.warn(_1c8);};dojo.experimental=function(_1c9,_1ca){var _1cb="EXPERIMENTAL: "+_1c9+" -- APIs subject to change without notice.";if(_1ca){_1cb+=" "+_1ca;}console.warn(_1cb);};}1||has.add("dojo-modulePaths",1);if(1){if(_1bd.modulePaths){dojo.deprecated("dojo.modulePaths","use paths configuration");var _1cc={};for(p in _1bd.modulePaths){_1cc[p.replace(/\./g,"/")]=_1bd.modulePaths[p];}_1be({paths:_1cc});}}1||has.add("dojo-moduleUrl",1);if(1){dojo.moduleUrl=function(_1cd,url){dojo.deprecated("dojo.moduleUrl()","use require.toUrl","2.0");var _1ce=null;if(_1cd){_1ce=_1be.toUrl(_1cd.replace(/\./g,"/")+(url?("/"+url):"")+"/*.*").replace(/\/\*\.\*/,"")+(url?"":"/");}return _1ce;};}dojo._hasResource={};return dojo;});},"dojo/io-query":function(){define(["./_base/lang"],function(lang){var _1cf={};return {objectToQuery:function objectToQuery(map){var enc=encodeURIComponent,_1d0=[];for(var name in map){var _1d1=map[name];if(_1d1!=_1cf[name]){var _1d2=enc(name)+"=";if(lang.isArray(_1d1)){for(var i=0,l=_1d1.length;i=0;i--){var node=(_20b?this._cloneNode(ary[i]):ary[i]);if(ary._runParse&&dojo.parser&&dojo.parser.parse){if(!_20d){_20d=_20c.ownerDocument.createElement("div");}_20d.appendChild(node);dojo.parser.parse(_20d);node=_20d.firstChild;while(_20d.firstChild){_20d.removeChild(_20d.firstChild);}}if(i==_20e-1){_1fb.place(node,_20c,_20a);}else{_20c.parentNode.insertBefore(node,_20c);}_20c=node;}},position:aam(_1fc.position),attr:awc(_202(_1fd),_1ff),style:awc(_202(_1fe),_1ff),addClass:aafe(_1fa.add),removeClass:aafe(_1fa.remove),toggleClass:aafe(_1fa.toggle),replaceClass:aafe(_1fa.replace),empty:aafe(_1fb.empty),removeAttr:aafe(_1fd.remove),marginBox:aam(_1fc.getMarginBox),place:function(_20f,_210){var item=_1f8(_20f)[0];return this.forEach(function(node){_1fb.place(node,item,_210);});},orphan:function(_211){return (_211?_1f8._filterResult(this,_211):this).forEach(_200);},adopt:function(_212,_213){return _1f8(_212).place(this[0],_213)._stash(this);},query:function(_214){if(!_214){return this;}var ret=new _201;this.map(function(node){_1f8(_214,node).forEach(function(_215){if(_215!==undefined){ret.push(_215);}});});return ret._stash(this);},filter:function(_216){var a=arguments,_217=this,_218=0;if(typeof _216=="string"){_217=_1f8._filterResult(this,a[0]);if(a.length==1){return _217._stash(this);}_218=1;}return this._wrap(_1f9.filter(_217,a[_218],a[_218+1]),this);},addContent:function(_219,_21a){_219=this._normalize(_219,this[0]);for(var i=0,node;(node=this[i]);i++){this._place(_219,node,_21a,i>0);}return this;}});return _201;});},"dojo/query":function(){define(["./_base/kernel","./has","./dom","./on","./_base/array","./_base/lang","./selector/_loader","./selector/_loader!default"],function(dojo,has,dom,on,_21b,lang,_21c,_21d){"use strict";has.add("array-extensible",function(){return lang.delegate([],{length:1}).length==1&&!has("bug-for-in-skips-shadowed");});var ap=Array.prototype,aps=ap.slice,apc=ap.concat,_21e=_21b.forEach;var tnl=function(a,_21f,_220){var _221=new (_220||this._NodeListCtor||nl)(a);return _21f?_221._stash(_21f):_221;};var _222=function(f,a,o){a=[0].concat(aps.call(a,0));o=o||dojo.global;return function(node){a[0]=node;return f.apply(o,a);};};var _223=function(f,o){return function(){this.forEach(_222(f,arguments,o));return this;};};var _224=function(f,o){return function(){return this.map(_222(f,arguments,o));};};var _225=function(f,o){return function(){return this.filter(_222(f,arguments,o));};};var _226=function(f,g,o){return function(){var a=arguments,body=_222(f,a,o);if(g.call(o||dojo.global,a)){return this.map(body);}this.forEach(body);return this;};};var _227=function(_228){var _229=this instanceof nl&&has("array-extensible");if(typeof _228=="number"){_228=Array(_228);}var _22a=(_228&&"length" in _228)?_228:arguments;if(_229||!_22a.sort){var _22b=_229?this:[],l=_22b.length=_22a.length;for(var i=0;i0;};_23c.filter=_23a.filter||function(_240,_241,root){return _23c(_241,root).filter(function(node){return _21b.indexOf(_240,node)>-1;});};if(typeof _23a!="function"){var _242=_23a.search;_23a=function(_243,root){return _242(root||document,_243);};}return _23c;};var _236=_239(_21d,_227);dojo.query=_239(_21d,function(_244){return _227(_244);});_236.load=function(id,_245,_246){_21c.load(id,_245,function(_247){_246(_239(_247,_227));});};dojo._filterQueryResult=_236._filterResult=function(_248,_249,root){return new _227(_236.filter(_248,_249,root));};dojo.NodeList=_236.NodeList=_227;return _236;});},"dojo/has":function(){define(["require","module"],function(_24a,_24b){var has=_24a.has||function(){};if(!1){var _24c=typeof window!="undefined"&&typeof location!="undefined"&&typeof document!="undefined"&&window.location==location&&window.document==document,_24d=this,doc=_24c&&document,_24e=doc&&doc.createElement("DiV"),_24f=(_24b.config&&_24b.config())||{};has=function(name){return typeof _24f[name]=="function"?(_24f[name]=_24f[name](_24d,doc,_24e)):_24f[name];};has.cache=_24f;has.add=function(name,test,now,_250){(typeof _24f[name]=="undefined"||_250)&&(_24f[name]=test);return now&&has(name);};1||has.add("host-browser",_24c);1||has.add("dom",_24c);1||has.add("dojo-dom-ready-api",1);1||has.add("dojo-sniff",1);}if(1){has.add("dom-addeventlistener",!!document.addEventListener);has.add("touch","ontouchstart" in document);has.add("device-width",screen.availWidth||innerWidth);var form=document.createElement("form");has.add("dom-attributes-explicit",form.attributes.length==0);has.add("dom-attributes-specified-flag",form.attributes.length>0&&form.attributes.length<40);}has.clearElement=function(_251){_251.innerHTML="";return _251;};has.normalize=function(id,_252){var _253=id.match(/[\?:]|[^:\?]*/g),i=0,get=function(skip){var term=_253[i++];if(term==":"){return 0;}else{if(_253[i++]=="?"){if(!skip&&has(term)){return get();}else{get(true);return get(skip);}}return term||0;}};id=get();return id&&_252(id);};has.load=function(id,_254,_255){if(id){_254([id],_255);}else{_255();}};return has;});},"dojo/_base/loader":function(){define(["./kernel","../has","require","module","./json","./lang","./array"],function(dojo,has,_256,_257,json,lang,_258){if(!1){console.error("cannot load the Dojo v1.x loader with a foreign loader");return 0;}1||has.add("dojo-fast-sync-require",1);var _259=function(id){return {src:_257.id,id:id};},_25a=function(name){return name.replace(/\./g,"/");},_25b=/\/\/>>built/,_25c=[],_25d=[],_25e=function(mid,_25f,_260){_25c.push(_260);_258.forEach(mid.split(","),function(mid){var _261=_262(mid,_25f.module);_25d.push(_261);_263(_261);});_264();},_264=(1?function(){var _265,mid;for(mid in _266){_265=_266[mid];if(_265.noReqPluginCheck===undefined){_265.noReqPluginCheck=/loadInit\!/.test(mid)||/require\!/.test(mid)?1:0;}if(!_265.executed&&!_265.noReqPluginCheck&&_265.injected==_267){return;}}_268(function(){var _269=_25c;_25c=[];_258.forEach(_269,function(cb){cb(1);});});}:(function(){var _26a,_26b=function(m){_26a[m.mid]=1;for(var t,_26c,deps=m.deps||[],i=0;i=0;--j){_2ce=lin[j].prototype;if(!_2ce.hasOwnProperty("declaredClass")){_2ce.declaredClass="uniqName_"+(_2c5++);}name=_2ce.declaredClass;if(!_2cc.hasOwnProperty(name)){_2cc[name]={count:0,refs:[],cls:lin[j]};++_2cd;}rec=_2cc[name];if(top&&top!==rec){rec.refs.push(top);++top.count;}top=rec;}++top.count;_2cb[0].refs.push(top);}while(_2cb.length){top=_2cb.pop();_2ca.push(top.cls);--_2cd;while(refs=top.refs,refs.length==1){top=refs[0];if(!top||--top.count){top=0;break;}_2ca.push(top.cls);--_2cd;}if(top){for(i=0,l=refs.length;i=0;--i){f=_2e8[i];m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,_2ea?_2ea[i]:a);}}f=this.postscript;if(f){f.apply(this,args);}};};function _2ec(ctor,_2ed){return function(){var a=arguments,t=a,a0=a[0],f;if(!(this instanceof a.callee)){return _2eb(a);}if(_2ed){if(a0){f=a0.preamble;if(f){t=f.apply(this,t)||t;}}f=this.preamble;if(f){f.apply(this,t);}}if(ctor){ctor.apply(this,a);}f=this.postscript;if(f){f.apply(this,a);}};};function _2ee(_2ef){return function(){var a=arguments,i=0,f,m;if(!(this instanceof a.callee)){return _2eb(a);}for(;f=_2ef[i];++i){m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,a);break;}}f=this.postscript;if(f){f.apply(this,a);}};};function _2f0(name,_2f1,_2f2){return function(){var b,m,f,i=0,step=1;if(_2f2){i=_2f1.length-1;step=-1;}for(;b=_2f1[i];i+=step){m=b._meta;f=(m?m.hidden:b.prototype)[name];if(f){f.apply(this,arguments);}}};};function _2f3(ctor){xtor.prototype=ctor.prototype;var t=new xtor;xtor.prototype=null;return t;};function _2eb(args){var ctor=args.callee,t=_2f3(ctor);ctor.apply(t,args);return t;};function _2e4(_2f4,_2f5,_2f6){if(typeof _2f4!="string"){_2f6=_2f5;_2f5=_2f4;_2f4="";}_2f6=_2f6||{};var _2f7,i,t,ctor,name,_2f8,_2f9,_2fa=1,_2fb=_2f5;if(opts.call(_2f5)=="[object Array]"){_2f8=_2c7(_2f5,_2f4);t=_2f8[0];_2fa=_2f8.length-t;_2f5=_2f8[_2fa];}else{_2f8=[0];if(_2f5){if(opts.call(_2f5)=="[object Function]"){t=_2f5._meta;_2f8=_2f8.concat(t?t.bases:_2f5);}else{err("base class is not a callable constructor.",_2f4);}}else{if(_2f5!==null){err("unknown base class. Did you use dojo.require to pull it in?",_2f4);}}}if(_2f5){for(i=_2fa-1;;--i){_2f7=_2f3(_2f5);if(!i){break;}t=_2f8[i];(t._meta?_2da:mix)(_2f7,t.prototype);ctor=new Function;ctor.superclass=_2f5;ctor.prototype=_2f7;_2f5=_2f7.constructor=ctor;}}else{_2f7={};}_2e4.safeMixin(_2f7,_2f6);t=_2f6.constructor;if(t!==op.constructor){t.nom=_2c6;_2f7.constructor=t;}for(i=_2fa-1;i;--i){t=_2f8[i]._meta;if(t&&t.chains){_2f9=mix(_2f9||{},t.chains);}}if(_2f7["-chains-"]){_2f9=mix(_2f9||{},_2f7["-chains-"]);}t=!_2f9||!_2f9.hasOwnProperty(_2c6);_2f8[0]=ctor=(_2f9&&_2f9.constructor==="manual")?_2ee(_2f8):(_2f8.length==1?_2ec(_2f6.constructor,t):_2e7(_2f8,t));ctor._meta={bases:_2f8,hidden:_2f6,chains:_2f9,parents:_2fb,ctor:_2f6.constructor};ctor.superclass=_2f5&&_2f5.prototype;ctor.extend=_2e2;ctor.createSubclass=_2e5;ctor.prototype=_2f7;_2f7.constructor=ctor;_2f7.getInherited=_2d5;_2f7.isInstanceOf=_2d8;_2f7.inherited=_2d7;_2f7.__inherited=_2cf;if(_2f4){_2f7.declaredClass=_2f4;lang.setObject(_2f4,ctor);}if(_2f9){for(name in _2f9){if(_2f7[name]&&typeof _2f9[name]=="string"&&name!=_2c6){t=_2f7[name]=_2f0(name,_2f8,_2f9[name]==="after");t.nom=name;}}}return ctor;};dojo.safeMixin=_2e4.safeMixin=_2de;dojo.declare=_2e4;return _2e4;});},"dojo/dom":function(){define(["./sniff","./_base/lang","./_base/window"],function(has,lang,win){if(has("ie")<=7){try{document.execCommand("BackgroundImageCache",false,true);}catch(e){}}var dom={};if(has("ie")){dom.byId=function(id,doc){if(typeof id!="string"){return id;}var _2fc=doc||win.doc,te=id&&_2fc.getElementById(id);if(te&&(te.attributes.id.value==id||te.id==id)){return te;}else{var eles=_2fc.all[id];if(!eles||eles.nodeName){eles=[eles];}var i=0;while((te=eles[i++])){if((te.attributes&&te.attributes.id&&te.attributes.id.value==id)||te.id==id){return te;}}}};}else{dom.byId=function(id,doc){return ((typeof id=="string")?(doc||win.doc).getElementById(id):id)||null;};}dom.isDescendant=function(node,_2fd){try{node=dom.byId(node);_2fd=dom.byId(_2fd);while(node){if(node==_2fd){return true;}node=node.parentNode;}}catch(e){}return false;};dom.setSelectable=function(node,_2fe){node=dom.byId(node);if(has("mozilla")){node.style.MozUserSelect=_2fe?"":"none";}else{if(has("khtml")||has("webkit")){node.style.KhtmlUserSelect=_2fe?"auto":"none";}else{if(has("ie")){var v=(node.unselectable=_2fe?"":"on"),cs=node.getElementsByTagName("*"),i=0,l=cs.length;for(;i=0){_306+=" * ";}else{_306+=" ";}var ts=function(s,e){return trim(_306.slice(s,e));};var _307=[];var _308=-1,_309=-1,_30a=-1,_30b=-1,_30c=-1,inId=-1,_30d=-1,_30e,lc="",cc="",_30f;var x=0,ql=_306.length,_310=null,_311=null;var _312=function(){if(_30d>=0){var tv=(_30d==x)?null:ts(_30d,x);_310[(_302.indexOf(tv)<0)?"tag":"oper"]=tv;_30d=-1;}};var _313=function(){if(inId>=0){_310.id=ts(inId,x).replace(/\\/g,"");inId=-1;}};var _314=function(){if(_30c>=0){_310.classes.push(ts(_30c+1,x).replace(/\\/g,""));_30c=-1;}};var _315=function(){_313();_312();_314();};var _316=function(){_315();if(_30b>=0){_310.pseudos.push({name:ts(_30b+1,x)});}_310.loops=(_310.pseudos.length||_310.attrs.length||_310.classes.length);_310.oquery=_310.query=ts(_30f,x);_310.otag=_310.tag=(_310["oper"])?null:(_310.tag||"*");if(_310.tag){_310.tag=_310.tag.toUpperCase();}if(_307.length&&(_307[_307.length-1].oper)){_310.infixOper=_307.pop();_310.query=_310.infixOper.query+" "+_310.query;}_307.push(_310);_310=null;};for(;lc=cc,cc=_306.charAt(x),x=0){if(cc=="]"){if(!_311.attr){_311.attr=ts(_308+1,x);}else{_311.matchFor=ts((_30a||_308+1),x);}var cmf=_311.matchFor;if(cmf){if((cmf.charAt(0)=="\"")||(cmf.charAt(0)=="'")){_311.matchFor=cmf.slice(1,-1);}}if(_311.matchFor){_311.matchFor=_311.matchFor.replace(/\\/g,"");}_310.attrs.push(_311);_311=null;_308=_30a=-1;}else{if(cc=="="){var _317=("|~^$*".indexOf(lc)>=0)?lc:"";_311.type=_317+cc;_311.attr=ts(_308+1,x-_317.length);_30a=x+1;}}}else{if(_309>=0){if(cc==")"){if(_30b>=0){_311.value=ts(_309+1,x);}_30b=_309=-1;}}else{if(cc=="#"){_315();inId=x+1;}else{if(cc=="."){_315();_30c=x;}else{if(cc==":"){_315();_30b=x;}else{if(cc=="["){_315();_308=x;_311={};}else{if(cc=="("){if(_30b>=0){_311={name:ts(_30b+1,x),value:null};_310.pseudos.push(_311);}_309=x;}else{if((cc==" ")&&(lc!=cc)){_316();}}}}}}}}}return _307;};var _318=function(_319,_31a){if(!_319){return _31a;}if(!_31a){return _319;}return function(){return _319.apply(window,arguments)&&_31a.apply(window,arguments);};};var _31b=function(i,arr){var r=arr||[];if(i){r.push(i);}return r;};var _31c=function(n){return (1==n.nodeType);};var _31d="";var _31e=function(elem,attr){if(!elem){return _31d;}if(attr=="class"){return elem.className||_31d;}if(attr=="for"){return elem.htmlFor||_31d;}if(attr=="style"){return elem.style.cssText||_31d;}return (_303?elem.getAttribute(attr):elem.getAttribute(attr,2))||_31d;};var _31f={"*=":function(attr,_320){return function(elem){return (_31e(elem,attr).indexOf(_320)>=0);};},"^=":function(attr,_321){return function(elem){return (_31e(elem,attr).indexOf(_321)==0);};},"$=":function(attr,_322){return function(elem){var ea=" "+_31e(elem,attr);var _323=ea.lastIndexOf(_322);return _323>-1&&(_323==(ea.length-_322.length));};},"~=":function(attr,_324){var tval=" "+_324+" ";return function(elem){var ea=" "+_31e(elem,attr)+" ";return (ea.indexOf(tval)>=0);};},"|=":function(attr,_325){var _326=_325+"-";return function(elem){var ea=_31e(elem,attr);return ((ea==_325)||(ea.indexOf(_326)==0));};},"=":function(attr,_327){return function(elem){return (_31e(elem,attr)==_327);};}};var _328=(typeof _300().firstChild.nextElementSibling=="undefined");var _329=!_328?"nextElementSibling":"nextSibling";var _32a=!_328?"previousElementSibling":"previousSibling";var _32b=(_328?_31c:_304);var _32c=function(node){while(node=node[_32a]){if(_32b(node)){return false;}}return true;};var _32d=function(node){while(node=node[_329]){if(_32b(node)){return false;}}return true;};var _32e=function(node){var root=node.parentNode;root=root.nodeType!=7?root:root.nextSibling;var i=0,tret=root.children||root.childNodes,ci=(node["_i"]||node.getAttribute("_i")||-1),cl=(root["_l"]||(typeof root.getAttribute!=="undefined"?root.getAttribute("_l"):-1));if(!tret){return -1;}var l=tret.length;if(cl==l&&ci>=0&&cl>=0){return ci;}if(has("ie")&&typeof root.setAttribute!=="undefined"){root.setAttribute("_l",l);}else{root["_l"]=l;}ci=-1;for(var te=root["firstElementChild"]||root["firstChild"];te;te=te[_329]){if(_32b(te)){if(has("ie")){te.setAttribute("_i",++i);}else{te["_i"]=++i;}if(node===te){ci=i;}}}return ci;};var _32f=function(elem){return !((_32e(elem))%2);};var _330=function(elem){return ((_32e(elem))%2);};var _331={"checked":function(name,_332){return function(elem){return !!("checked" in elem?elem.checked:elem.selected);};},"disabled":function(name,_333){return function(elem){return elem.disabled;};},"enabled":function(name,_334){return function(elem){return !elem.disabled;};},"first-child":function(){return _32c;},"last-child":function(){return _32d;},"only-child":function(name,_335){return function(node){return _32c(node)&&_32d(node);};},"empty":function(name,_336){return function(elem){var cn=elem.childNodes;var cnl=elem.childNodes.length;for(var x=cnl-1;x>=0;x--){var nt=cn[x].nodeType;if((nt===1)||(nt==3)){return false;}}return true;};},"contains":function(name,_337){var cz=_337.charAt(0);if(cz=="\""||cz=="'"){_337=_337.slice(1,-1);}return function(elem){return (elem.innerHTML.indexOf(_337)>=0);};},"not":function(name,_338){var p=_305(_338)[0];var _339={el:1};if(p.tag!="*"){_339.tag=1;}if(!p.classes.length){_339.classes=1;}var ntf=_33a(p,_339);return function(elem){return (!ntf(elem));};},"nth-child":function(name,_33b){var pi=parseInt;if(_33b=="odd"){return _330;}else{if(_33b=="even"){return _32f;}}if(_33b.indexOf("n")!=-1){var _33c=_33b.split("n",2);var pred=_33c[0]?((_33c[0]=="-")?-1:pi(_33c[0])):1;var idx=_33c[1]?pi(_33c[1]):0;var lb=0,ub=-1;if(pred>0){if(idx<0){idx=(idx%pred)&&(pred+(idx%pred));}else{if(idx>0){if(idx>=pred){lb=idx-idx%pred;}idx=idx%pred;}}}else{if(pred<0){pred*=-1;if(idx>0){ub=idx;idx=idx%pred;}}}if(pred>0){return function(elem){var i=_32e(elem);return (i>=lb)&&(ub<0||i<=ub)&&((i%pred)==idx);};}else{_33b=idx;}}var _33d=pi(_33b);return function(elem){return (_32e(elem)==_33d);};}};var _33e=(has("ie")&&(has("ie")<9||has("quirks")))?function(cond){var clc=cond.toLowerCase();if(clc=="class"){cond="className";}return function(elem){return (_303?elem.getAttribute(cond):elem[cond]||elem[clc]);};}:function(cond){return function(elem){return (elem&&elem.getAttribute&&elem.hasAttribute(cond));};};var _33a=function(_33f,_340){if(!_33f){return _304;}_340=_340||{};var ff=null;if(!("el" in _340)){ff=_318(ff,_31c);}if(!("tag" in _340)){if(_33f.tag!="*"){ff=_318(ff,function(elem){return (elem&&((_303?elem.tagName:elem.tagName.toUpperCase())==_33f.getTag()));});}}if(!("classes" in _340)){each(_33f.classes,function(_341,idx,arr){var re=new RegExp("(?:^|\\s)"+_341+"(?:\\s|$)");ff=_318(ff,function(elem){return re.test(elem.className);});ff.count=idx;});}if(!("pseudos" in _340)){each(_33f.pseudos,function(_342){var pn=_342.name;if(_331[pn]){ff=_318(ff,_331[pn](pn,_342.value));}});}if(!("attrs" in _340)){each(_33f.attrs,function(attr){var _343;var a=attr.attr;if(attr.type&&_31f[attr.type]){_343=_31f[attr.type](a,attr.matchFor);}else{if(a.length){_343=_33e(a);}}if(_343){ff=_318(ff,_343);}});}if(!("id" in _340)){if(_33f.id){ff=_318(ff,function(elem){return (!!elem&&(elem.id==_33f.id));});}}if(!ff){if(!("default" in _340)){ff=_304;}}return ff;};var _344=function(_345){return function(node,ret,bag){while(node=node[_329]){if(_328&&(!_31c(node))){continue;}if((!bag||_346(node,bag))&&_345(node)){ret.push(node);}break;}return ret;};};var _347=function(_348){return function(root,ret,bag){var te=root[_329];while(te){if(_32b(te)){if(bag&&!_346(te,bag)){break;}if(_348(te)){ret.push(te);}}te=te[_329];}return ret;};};var _349=function(_34a){_34a=_34a||_304;return function(root,ret,bag){var te,x=0,tret=root.children||root.childNodes;while(te=tret[x++]){if(_32b(te)&&(!bag||_346(te,bag))&&(_34a(te,x))){ret.push(te);}}return ret;};};var _34b=function(node,root){var pn=node.parentNode;while(pn){if(pn==root){break;}pn=pn.parentNode;}return !!pn;};var _34c={};var _34d=function(_34e){var _34f=_34c[_34e.query];if(_34f){return _34f;}var io=_34e.infixOper;var oper=(io?io.oper:"");var _350=_33a(_34e,{el:1});var qt=_34e.tag;var _351=("*"==qt);var ecs=_300()["getElementsByClassName"];if(!oper){if(_34e.id){_350=(!_34e.loops&&_351)?_304:_33a(_34e,{el:1,id:1});_34f=function(root,arr){var te=dom.byId(_34e.id,(root.ownerDocument||root));if(!te||!_350(te)){return;}if(9==root.nodeType){return _31b(te,arr);}else{if(_34b(te,root)){return _31b(te,arr);}}};}else{if(ecs&&/\{\s*\[native code\]\s*\}/.test(String(ecs))&&_34e.classes.length&&!_301){_350=_33a(_34e,{el:1,classes:1,id:1});var _352=_34e.classes.join(" ");_34f=function(root,arr,bag){var ret=_31b(0,arr),te,x=0;var tret=root.getElementsByClassName(_352);while((te=tret[x++])){if(_350(te,root)&&_346(te,bag)){ret.push(te);}}return ret;};}else{if(!_351&&!_34e.loops){_34f=function(root,arr,bag){var ret=_31b(0,arr),te,x=0;var tag=_34e.getTag(),tret=tag?root.getElementsByTagName(tag):[];while((te=tret[x++])){if(_346(te,bag)){ret.push(te);}}return ret;};}else{_350=_33a(_34e,{el:1,tag:1,id:1});_34f=function(root,arr,bag){var ret=_31b(0,arr),te,x=0;var tag=_34e.getTag(),tret=tag?root.getElementsByTagName(tag):[];while((te=tret[x++])){if(_350(te,root)&&_346(te,bag)){ret.push(te);}}return ret;};}}}}else{var _353={el:1};if(_351){_353.tag=1;}_350=_33a(_34e,_353);if("+"==oper){_34f=_344(_350);}else{if("~"==oper){_34f=_347(_350);}else{if(">"==oper){_34f=_349(_350);}}}}return _34c[_34e.query]=_34f;};var _354=function(root,_355){var _356=_31b(root),qp,x,te,qpl=_355.length,bag,ret;for(var i=0;i0){bag={};ret.nozip=true;}var gef=_34d(qp);for(var j=0;(te=_356[j]);j++){gef(te,ret,bag);}if(!ret.length){break;}_356=ret;}return ret;};var _357={},_358={};var _359=function(_35a){var _35b=_305(trim(_35a));if(_35b.length==1){var tef=_34d(_35b[0]);return function(root){var r=tef(root,[]);if(r){r.nozip=true;}return r;};}return function(root){return _354(root,_35b);};};var _35c=has("ie")?"commentStrip":"nozip";var qsa="querySelectorAll";var _35d=!!_300()[qsa];var _35e=/\\[>~+]|n\+\d|([^ \\])?([>~+])([^ =])?/g;var _35f=function(_360,pre,ch,post){return ch?(pre?pre+" ":"")+ch+(post?" "+post:""):_360;};var _361=/([^[]*)([^\]]*])?/g;var _362=function(_363,_364,att){return _364.replace(_35e,_35f)+(att||"");};var _365=function(_366,_367){_366=_366.replace(_361,_362);if(_35d){var _368=_358[_366];if(_368&&!_367){return _368;}}var _369=_357[_366];if(_369){return _369;}var qcz=_366.charAt(0);var _36a=(-1==_366.indexOf(" "));if((_366.indexOf("#")>=0)&&(_36a)){_367=true;}var _36b=(_35d&&(!_367)&&(_302.indexOf(qcz)==-1)&&(!has("ie")||(_366.indexOf(":")==-1))&&(!(_301&&(_366.indexOf(".")>=0)))&&(_366.indexOf(":contains")==-1)&&(_366.indexOf(":checked")==-1)&&(_366.indexOf("|=")==-1));if(_36b){var tq=(_302.indexOf(_366.charAt(_366.length-1))>=0)?(_366+" *"):_366;return _358[_366]=function(root){try{if(!((9==root.nodeType)||_36a)){throw "";}var r=root[qsa](tq);r[_35c]=true;return r;}catch(e){return _365(_366,true)(root);}};}else{var _36c=_366.match(/([^\s,](?:"(?:\\.|[^"])+"|'(?:\\.|[^'])+'|[^,])*)/g);return _357[_366]=((_36c.length<2)?_359(_366):function(root){var _36d=0,ret=[],tp;while((tp=_36c[_36d++])){ret=ret.concat(_359(tp)(root));}return ret;});}};var _36e=0;var _36f=has("ie")?function(node){if(_303){return (node.getAttribute("_uid")||node.setAttribute("_uid",++_36e)||_36e);}else{return node.uniqueID;}}:function(node){return (node._uid||(node._uid=++_36e));};var _346=function(node,bag){if(!bag){return 1;}var id=_36f(node);if(!bag[id]){return bag[id]=1;}return 0;};var _370="_zipIdx";var _371=function(arr){if(arr&&arr.nozip){return arr;}var ret=[];if(!arr||!arr.length){return ret;}if(arr[0]){ret.push(arr[0]);}if(arr.length<2){return ret;}_36e++;var x,te;if(has("ie")&&_303){var _372=_36e+"";arr[0].setAttribute(_370,_372);for(x=1;te=arr[x];x++){if(arr[x].getAttribute(_370)!=_372){ret.push(te);}te.setAttribute(_370,_372);}}else{if(has("ie")&&arr.commentStrip){try{for(x=1;te=arr[x];x++){if(_31c(te)){ret.push(te);}}}catch(e){}}else{if(arr[0]){arr[0][_370]=_36e;}for(x=1;te=arr[x];x++){if(arr[x][_370]!=_36e){ret.push(te);}te[_370]=_36e;}}}return ret;};var _373=function(_374,root){root=root||_300();var od=root.ownerDocument||root;_303=(od.createElement("div").tagName==="div");var r=_365(_374)(root);if(r&&r.nozip){return r;}return _371(r);};_373.filter=function(_375,_376,root){var _377=[],_378=_305(_376),_379=(_378.length==1&&!/[^\w#\.]/.test(_376))?_33a(_378[0]):function(node){return _2ff.indexOf(_373(_376,dom.byId(root)),node)!=-1;};for(var x=0,te;te=_375[x];x++){if(_379(te)){_377.push(te);}}return _377;};return _373;});},"dojo/errors/RequestTimeoutError":function(){define("dojo/errors/RequestTimeoutError",["./create","./RequestError"],function(_37a,_37b){return _37a("RequestTimeoutError",null,_37b,{dojoType:"timeout"});});},"dojo/dom-style":function(){define("dojo/dom-style",["./sniff","./dom"],function(has,dom){var _37c,_37d={};if(has("webkit")){_37c=function(node){var s;if(node.nodeType==1){var dv=node.ownerDocument.defaultView;s=dv.getComputedStyle(node,null);if(!s&&node.style){node.style.display="";s=dv.getComputedStyle(node,null);}}return s||{};};}else{if(has("ie")&&(has("ie")<9||has("quirks"))){_37c=function(node){return node.nodeType==1&&node.currentStyle?node.currentStyle:{};};}else{_37c=function(node){return node.nodeType==1?node.ownerDocument.defaultView.getComputedStyle(node,null):{};};}}_37d.getComputedStyle=_37c;var _37e;if(!has("ie")){_37e=function(_37f,_380){return parseFloat(_380)||0;};}else{_37e=function(_381,_382){if(!_382){return 0;}if(_382=="medium"){return 4;}if(_382.slice&&_382.slice(-2)=="px"){return parseFloat(_382);}var s=_381.style,rs=_381.runtimeStyle,cs=_381.currentStyle,_383=s.left,_384=rs.left;rs.left=cs.left;try{s.left=_382;_382=s.pixelLeft;}catch(e){_382=0;}s.left=_383;rs.left=_384;return _382;};}_37d.toPixelValue=_37e;var astr="DXImageTransform.Microsoft.Alpha";var af=function(n,f){try{return n.filters.item(astr);}catch(e){return f?{}:null;}};var _385=has("ie")<9||(has("ie")&&has("quirks"))?function(node){try{return af(node).Opacity/100;}catch(e){return 1;}}:function(node){return _37c(node).opacity;};var _386=has("ie")<9||(has("ie")&&has("quirks"))?function(node,_387){var ov=_387*100,_388=_387==1;node.style.zoom=_388?"":1;if(!af(node)){if(_388){return _387;}node.style.filter+=" progid:"+astr+"(Opacity="+ov+")";}else{af(node,1).Opacity=ov;}af(node,1).Enabled=!_388;if(node.tagName.toLowerCase()=="tr"){for(var td=node.firstChild;td;td=td.nextSibling){if(td.tagName.toLowerCase()=="td"){_386(td,_387);}}}return _387;}:function(node,_389){return node.style.opacity=_389;};var _38a={left:true,top:true};var _38b=/margin|padding|width|height|max|min|offset/;function _38c(node,type,_38d){type=type.toLowerCase();if(has("ie")){if(_38d=="auto"){if(type=="height"){return node.offsetHeight;}if(type=="width"){return node.offsetWidth;}}if(type=="fontweight"){switch(_38d){case 700:return "bold";case 400:default:return "normal";}}}if(!(type in _38a)){_38a[type]=_38b.test(type);}return _38a[type]?_37e(node,_38d):_38d;};var _38e=has("ie")?"styleFloat":"cssFloat",_38f={"cssFloat":_38e,"styleFloat":_38e,"float":_38e};_37d.get=function getStyle(node,name){var n=dom.byId(node),l=arguments.length,op=(name=="opacity");if(l==2&&op){return _385(n);}name=_38f[name]||name;var s=_37d.getComputedStyle(n);return (l==1)?s:_38c(n,name,s[name]||n.style[name]);};_37d.set=function setStyle(node,name,_390){var n=dom.byId(node),l=arguments.length,op=(name=="opacity");name=_38f[name]||name;if(l==3){return op?_386(n,_390):n.style[name]=_390;}for(var x in name){_37d.set(node,x,name[x]);}return _37d.getComputedStyle(n);};return _37d;});},"dojo/dom-geometry":function(){define(["./sniff","./_base/window","./dom","./dom-style"],function(has,win,dom,_391){var geom={};geom.boxModel="content-box";if(has("ie")){geom.boxModel=document.compatMode=="BackCompat"?"border-box":"content-box";}geom.getPadExtents=function getPadExtents(node,_392){node=dom.byId(node);var s=_392||_391.getComputedStyle(node),px=_391.toPixelValue,l=px(node,s.paddingLeft),t=px(node,s.paddingTop),r=px(node,s.paddingRight),b=px(node,s.paddingBottom);return {l:l,t:t,r:r,b:b,w:l+r,h:t+b};};var none="none";geom.getBorderExtents=function getBorderExtents(node,_393){node=dom.byId(node);var px=_391.toPixelValue,s=_393||_391.getComputedStyle(node),l=s.borderLeftStyle!=none?px(node,s.borderLeftWidth):0,t=s.borderTopStyle!=none?px(node,s.borderTopWidth):0,r=s.borderRightStyle!=none?px(node,s.borderRightWidth):0,b=s.borderBottomStyle!=none?px(node,s.borderBottomWidth):0;return {l:l,t:t,r:r,b:b,w:l+r,h:t+b};};geom.getPadBorderExtents=function getPadBorderExtents(node,_394){node=dom.byId(node);var s=_394||_391.getComputedStyle(node),p=geom.getPadExtents(node,s),b=geom.getBorderExtents(node,s);return {l:p.l+b.l,t:p.t+b.t,r:p.r+b.r,b:p.b+b.b,w:p.w+b.w,h:p.h+b.h};};geom.getMarginExtents=function getMarginExtents(node,_395){node=dom.byId(node);var s=_395||_391.getComputedStyle(node),px=_391.toPixelValue,l=px(node,s.marginLeft),t=px(node,s.marginTop),r=px(node,s.marginRight),b=px(node,s.marginBottom);return {l:l,t:t,r:r,b:b,w:l+r,h:t+b};};geom.getMarginBox=function getMarginBox(node,_396){node=dom.byId(node);var s=_396||_391.getComputedStyle(node),me=geom.getMarginExtents(node,s),l=node.offsetLeft-me.l,t=node.offsetTop-me.t,p=node.parentNode,px=_391.toPixelValue,pcs;if(has("mozilla")){var sl=parseFloat(s.left),st=parseFloat(s.top);if(!isNaN(sl)&&!isNaN(st)){l=sl;t=st;}else{if(p&&p.style){pcs=_391.getComputedStyle(p);if(pcs.overflow!="visible"){l+=pcs.borderLeftStyle!=none?px(node,pcs.borderLeftWidth):0;t+=pcs.borderTopStyle!=none?px(node,pcs.borderTopWidth):0;}}}}else{if(has("opera")||(has("ie")==8&&!has("quirks"))){if(p){pcs=_391.getComputedStyle(p);l-=pcs.borderLeftStyle!=none?px(node,pcs.borderLeftWidth):0;t-=pcs.borderTopStyle!=none?px(node,pcs.borderTopWidth):0;}}}return {l:l,t:t,w:node.offsetWidth+me.w,h:node.offsetHeight+me.h};};geom.getContentBox=function getContentBox(node,_397){node=dom.byId(node);var s=_397||_391.getComputedStyle(node),w=node.clientWidth,h,pe=geom.getPadExtents(node,s),be=geom.getBorderExtents(node,s);if(!w){w=node.offsetWidth;h=node.offsetHeight;}else{h=node.clientHeight;be.w=be.h=0;}if(has("opera")){pe.l+=be.l;pe.t+=be.t;}return {l:pe.l,t:pe.t,w:w-pe.w-be.w,h:h-pe.h-be.h};};function _398(node,l,t,w,h,u){u=u||"px";var s=node.style;if(!isNaN(l)){s.left=l+u;}if(!isNaN(t)){s.top=t+u;}if(w>=0){s.width=w+u;}if(h>=0){s.height=h+u;}};function _399(node){return node.tagName.toLowerCase()=="button"||node.tagName.toLowerCase()=="input"&&(node.getAttribute("type")||"").toLowerCase()=="button";};function _39a(node){return geom.boxModel=="border-box"||node.tagName.toLowerCase()=="table"||_399(node);};geom.setContentSize=function setContentSize(node,box,_39b){node=dom.byId(node);var w=box.w,h=box.h;if(_39a(node)){var pb=geom.getPadBorderExtents(node,_39b);if(w>=0){w+=pb.w;}if(h>=0){h+=pb.h;}}_398(node,NaN,NaN,w,h);};var _39c={l:0,t:0,w:0,h:0};geom.setMarginBox=function setMarginBox(node,box,_39d){node=dom.byId(node);var s=_39d||_391.getComputedStyle(node),w=box.w,h=box.h,pb=_39a(node)?_39c:geom.getPadBorderExtents(node,s),mb=geom.getMarginExtents(node,s);if(has("webkit")){if(_399(node)){var ns=node.style;if(w>=0&&!ns.width){ns.width="4px";}if(h>=0&&!ns.height){ns.height="4px";}}}if(w>=0){w=Math.max(w-pb.w-mb.w,0);}if(h>=0){h=Math.max(h-pb.h-mb.h,0);}_398(node,box.l,box.t,w,h);};geom.isBodyLtr=function isBodyLtr(doc){doc=doc||win.doc;return (win.body(doc).dir||doc.documentElement.dir||"ltr").toLowerCase()=="ltr";};geom.docScroll=function docScroll(doc){doc=doc||win.doc;var node=win.doc.parentWindow||win.doc.defaultView;return "pageXOffset" in node?{x:node.pageXOffset,y:node.pageYOffset}:(node=has("quirks")?win.body(doc):doc.documentElement)&&{x:geom.fixIeBiDiScrollLeft(node.scrollLeft||0,doc),y:node.scrollTop||0};};if(has("ie")){geom.getIeDocumentElementOffset=function getIeDocumentElementOffset(doc){doc=doc||win.doc;var de=doc.documentElement;if(has("ie")<8){var r=de.getBoundingClientRect(),l=r.left,t=r.top;if(has("ie")<7){l+=de.clientLeft;t+=de.clientTop;}return {x:l<0?0:l,y:t<0?0:t};}else{return {x:0,y:0};}};}geom.fixIeBiDiScrollLeft=function fixIeBiDiScrollLeft(_39e,doc){doc=doc||win.doc;var ie=has("ie");if(ie&&!geom.isBodyLtr(doc)){var qk=has("quirks"),de=qk?win.body(doc):doc.documentElement,pwin=win.global;if(ie==6&&!qk&&pwin.frameElement&&de.scrollHeight>de.clientHeight){_39e+=de.clientLeft;}return (ie<8||qk)?(_39e+de.clientWidth-de.scrollWidth):-_39e;}return _39e;};geom.position=function(node,_39f){node=dom.byId(node);var db=win.body(node.ownerDocument),ret=node.getBoundingClientRect();ret={x:ret.left,y:ret.top,w:ret.right-ret.left,h:ret.bottom-ret.top};if(has("ie")){var _3a0=geom.getIeDocumentElementOffset(node.ownerDocument);ret.x-=_3a0.x+(has("quirks")?db.clientLeft+db.offsetLeft:0);ret.y-=_3a0.y+(has("quirks")?db.clientTop+db.offsetTop:0);}if(_39f){var _3a1=geom.docScroll(node.ownerDocument);ret.x+=_3a1.x;ret.y+=_3a1.y;}return ret;};geom.getMarginSize=function getMarginSize(node,_3a2){node=dom.byId(node);var me=geom.getMarginExtents(node,_3a2||_391.getComputedStyle(node));var size=node.getBoundingClientRect();return {w:(size.right-size.left)+me.w,h:(size.bottom-size.top)+me.h};};geom.normalizeEvent=function(_3a3){if(!("layerX" in _3a3)){_3a3.layerX=_3a3.offsetX;_3a3.layerY=_3a3.offsetY;}if(!has("dom-addeventlistener")){var se=_3a3.target;var doc=(se&&se.ownerDocument)||document;var _3a4=has("quirks")?doc.body:doc.documentElement;var _3a5=geom.getIeDocumentElementOffset(doc);_3a3.pageX=_3a3.clientX+geom.fixIeBiDiScrollLeft(_3a4.scrollLeft||0,doc)-_3a5.x;_3a3.pageY=_3a3.clientY+(_3a4.scrollTop||0)-_3a5.y;}};return geom;});},"dojo/dom-prop":function(){define(["exports","./_base/kernel","./sniff","./_base/lang","./dom","./dom-style","./dom-construct","./_base/connect"],function(_3a6,dojo,has,lang,dom,_3a7,ctr,conn){var _3a8={},_3a9=0,_3aa=dojo._scopeName+"attrid";_3a6.names={"class":"className","for":"htmlFor",tabindex:"tabIndex",readonly:"readOnly",colspan:"colSpan",frameborder:"frameBorder",rowspan:"rowSpan",valuetype:"valueType"};_3a6.get=function getProp(node,name){node=dom.byId(node);var lc=name.toLowerCase(),_3ab=_3a6.names[lc]||name;return node[_3ab];};_3a6.set=function setProp(node,name,_3ac){node=dom.byId(node);var l=arguments.length;if(l==2&&typeof name!="string"){for(var x in name){_3a6.set(node,x,name[x]);}return node;}var lc=name.toLowerCase(),_3ad=_3a6.names[lc]||name;if(_3ad=="style"&&typeof _3ac!="string"){_3a7.set(node,_3ac);return node;}if(_3ad=="innerHTML"){if(has("ie")&&node.tagName.toLowerCase() in {col:1,colgroup:1,table:1,tbody:1,tfoot:1,thead:1,tr:1,title:1}){ctr.empty(node);node.appendChild(ctr.toDom(_3ac,node.ownerDocument));}else{node[_3ad]=_3ac;}return node;}if(lang.isFunction(_3ac)){var _3ae=node[_3aa];if(!_3ae){_3ae=_3a9++;node[_3aa]=_3ae;}if(!_3a8[_3ae]){_3a8[_3ae]={};}var h=_3a8[_3ae][_3ad];if(h){conn.disconnect(h);}else{try{delete node[_3ad];}catch(e){}}if(_3ac){_3a8[_3ae][_3ad]=conn.connect(node,_3ad,_3ac);}else{node[_3ad]=null;}return node;}node[_3ad]=_3ac;return node;};});},"dojo/when":function(){define(["./Deferred","./promise/Promise"],function(_3af,_3b0){"use strict";return function when(_3b1,_3b2,_3b3,_3b4){var _3b5=_3b1&&typeof _3b1.then==="function";var _3b6=_3b5&&_3b1 instanceof _3b0;if(!_3b5){if(_3b2){return _3b2(_3b1);}else{return new _3af().resolve(_3b1);}}else{if(!_3b6){var _3b7=new _3af(_3b1.cancel);_3b1.then(_3b7.resolve,_3b7.reject,_3b7.progress);_3b1=_3b7.promise;}}if(_3b2||_3b3||_3b4){return _3b1.then(_3b2,_3b3,_3b4);}return _3b1;};});},"dojo/dom-attr":function(){define(["exports","./sniff","./_base/lang","./dom","./dom-style","./dom-prop"],function(_3b8,has,lang,dom,_3b9,prop){var _3ba={innerHTML:1,className:1,htmlFor:has("ie"),value:1},_3bb={classname:"class",htmlfor:"for",tabindex:"tabIndex",readonly:"readOnly"};function _3bc(node,name){var attr=node.getAttributeNode&&node.getAttributeNode(name);return attr&&attr.specified;};_3b8.has=function hasAttr(node,name){var lc=name.toLowerCase();return _3ba[prop.names[lc]||name]||_3bc(dom.byId(node),_3bb[lc]||name);};_3b8.get=function getAttr(node,name){node=dom.byId(node);var lc=name.toLowerCase(),_3bd=prop.names[lc]||name,_3be=_3ba[_3bd],_3bf=node[_3bd];if(_3be&&typeof _3bf!="undefined"){return _3bf;}if(_3bd!="href"&&(typeof _3bf=="boolean"||lang.isFunction(_3bf))){return _3bf;}var _3c0=_3bb[lc]||name;return _3bc(node,_3c0)?node.getAttribute(_3c0):null;};_3b8.set=function setAttr(node,name,_3c1){node=dom.byId(node);if(arguments.length==2){for(var x in name){_3b8.set(node,x,name[x]);}return node;}var lc=name.toLowerCase(),_3c2=prop.names[lc]||name,_3c3=_3ba[_3c2];if(_3c2=="style"&&typeof _3c1!="string"){_3b9.set(node,_3c1);return node;}if(_3c3||typeof _3c1=="boolean"||lang.isFunction(_3c1)){return prop.set(node,name,_3c1);}node.setAttribute(_3bb[lc]||name,_3c1);return node;};_3b8.remove=function removeAttr(node,name){dom.byId(node).removeAttribute(_3bb[name.toLowerCase()]||name);};_3b8.getNodeProp=function getNodeProp(node,name){node=dom.byId(node);var lc=name.toLowerCase(),_3c4=prop.names[lc]||name;if((_3c4 in node)&&_3c4!="href"){return node[_3c4];}var _3c5=_3bb[lc]||name;return _3bc(node,_3c5)?node.getAttribute(_3c5):null;};});},"dojo/dom-construct":function(){define(["exports","./_base/kernel","./sniff","./_base/window","./dom","./dom-attr","./on"],function(_3c6,dojo,has,win,dom,attr,on){var _3c7={option:["select"],tbody:["table"],thead:["table"],tfoot:["table"],tr:["table","tbody"],td:["table","tbody","tr"],th:["table","thead","tr"],legend:["fieldset"],caption:["table"],colgroup:["table"],col:["table","colgroup"],li:["ul"]},_3c8=/<\s*([\w\:]+)/,_3c9={},_3ca=0,_3cb="__"+dojo._scopeName+"ToDomId";for(var _3cc in _3c7){if(_3c7.hasOwnProperty(_3cc)){var tw=_3c7[_3cc];tw.pre=_3cc=="option"?"