"""

SOS Client main dialog.

"""

def __init__(self, parent=None, iface = None):

"""Constructor

:param parent: Parent object

:type parent: QWidget

:param iface: A QGIS interface instance.

:type iface: QgsInterface

"""

super(SOSClientDialog, self).__init__(parent)

settings = QtCore.QSettings ()

self.iface = iface

self.reply = None

self.service = None

self.filterRequest = None

self.createTimeManagerLayer = False

self.addLayerToTimeManager = lambda *a,**k: None

# Set up the user interface from Designer.

self.setupUi(self)

#Ayuda

self.btnBox.helpRequested.connect(lambda: showPluginHelp(filename="help/index"))

# Botón Añadir y Editar y añadir

self.btnAdd.setDefaultAction (self.actionAdd)

self.btnAdd.addAction(self.actionEditRequest)

self.btnBox.addButton(self.btnAdd, QtGui.QDialogButtonBox.ActionRole)

self.btnAdd.setEnabled(False)

#Guardar y cargar lista de servidores

self.btnSave.setVisible (False)

self.btnLoad.setVisible (False)

#Visor de información del servidor

self.htmlView.document().setDefaultStyleSheet(QgsApplication.reportStyleSheet())

self.htmlView.customContextMenuRequested.connect (lambda point, widget=self.htmlView, actions = [self.actionShowXML]: addContextMenuActions (point,widget, actions))

#Acciones de selección para listas

self.lstProperties.addAction(self.actionSelectAllProperties)

self.lstProperties.addAction(self.actionSelectNoneProperties)

self.lstProperties.addAction(self.actionSelectInvertProperties)

self.lstFeatures.addAction(self.actionSelectAllFeatures)

self.lstFeatures.addAction(self.actionSelectNoneFeatures)

self.lstFeatures.addAction(self.actionSelectInvertFeatures)

self.lstProcedures.addAction(self.actionSelectAllProcedures)

self.lstProcedures.addAction(self.actionSelectNoneProcedures)

self.lstProcedures.addAction(self.actionSelectInvertProcedures)

#Filtros

self.grpFilterSpatial.setEnabled (False)

self.lblSpatialFilterWarning.setVisible (False)

self.grpFilterTemporal.setEnabled (False)

self.grpFilterScalar.setEnabled (False)

#Listar conexiones

self.populateConnectionList ()

#Directorio de trabajo

self.workDirName.setText(settings.value("SOSClient/workDir", QtCore.QDir.tempPath(), type=str))

self.workDirName.textChanged.connect (lambda value : settings.setValue("SOSClient/workDir", value))

@property

def selectedOffering (self):

try:

return self.cmbOfferings.itemData(self.cmbOfferings.currentIndex())

except: return ""

@property

def selectedProperties (self):

try: return self.lstProperties.model().stringListChecked

except: return []

@property

def selectedFeaturesOfInterest (self):

try: return self.lstFeatures.model().stringListChecked

except: return []

@property

def selectedProcedures (self):

try: return self.lstProcedures.model().stringListChecked

except: return []

@property

def selectedResultModel (self):

try: return self.cmbResultModel.currentText()

except: return ""

@property

def selectedWorkDir (self):

try: return self.workDirName.text

except: return ""

def populateConnectionList(self):

self.cmbConnections.blockSignals(True)

self.cmbConnections.clear()

keys = QgsOWSConnection.connectionList("SOS")

self.cmbConnections.addItems (keys)

self.cmbConnections.blockSignals(False)

index = self.cmbConnections.findText(QgsOWSConnection.selectedConnection("SOS"))

self.cmbConnections.setCurrentIndex(index)

self.on_cmbConnections_currentIndexChanged (QgsOWSConnection.selectedConnection("SOS"))

QgsDebug ("populateConnectionList: selectedConnection = {}".format(QgsOWSConnection.selectedConnection("SOS")))

@QtCore.pyqtSlot(str)

def on_cmbConnections_currentIndexChanged (self, text):

text = str(text)

if QgsOWSConnection.selectedConnection("SOS") != text:

QgsOWSConnection.setSelectedConnection("SOS", text)

if text != "":

self.btnConnect.setEnabled(True)

self.btnEdit.setEnabled(True)

self.btnDelete.setEnabled(True)

else:

self.btnConnect.setEnabled(False)

self.btnEdit.setEnabled(False)

self.btnDelete.setEnabled(False)

@QtCore.pyqtSlot()

def on_btnConnect_clicked(self):

self.cmbOfferings.clear()

self.htmlView.setText ("")

self.btnAdd.setEnabled(False)

self.btnConnect.setEnabled(False)

connection = QgsOWSConnection("SOS", QgsOWSConnection.selectedConnection("SOS"))

url = str(connection.uri().param('url'))

QgsMessageLog.logMessage(self.tr("Connecting to {url}").format(url=url), "SosClient", QgsMessageLog.INFO)

if url != "" :

self.executeRequest(SensorObservationService.capabilitiesUrl(url), self.capabilitiesRequest)

@QtCore.pyqtSlot()

def on_btnNew_clicked(self):

nc = QgsNewHttpConnection (self, "/Qgis/connections-sos/")

nc.setWindowTitle(self.tr("Create a new SOS connection"))

if nc.exec_():

self.populateConnectionList()

@QtCore.pyqtSlot()

def on_btnEdit_clicked(self):

nc = QgsNewHttpConnection (self, "/Qgis/connections-sos/", self.cmbConnections.currentText())

nc.setWindowTitle(self.tr("Modify SOS connection"))

if nc.exec_():

self.populateConnectionList()

@QtCore.pyqtSlot()

def on_btnDelete_clicked(self):

msg = str (self.tr("Are you sure you want to remove the %s connection and all associated settings?")) % (self.cmbConnections.currentText())

result = QtGui.QMessageBox.information(self, self.tr("Confirm Delete"), msg, QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel)

if result == QtGui.QMessageBox.Ok :

QgsOWSConnection.deleteConnection("SOS", self.cmbConnections.currentText())

self.populateConnectionList()

@QtCore.pyqtSlot()

def on_btnSave_clicked (self):

pass

@QtCore.pyqtSlot(int)

def on_cmbOfferings_activated(self, index):

offer = self.cmbOfferings.itemData(index) if index > -1 else ""

QgsDebug ("on_cmbOfferings_activated {}: {}".format(index, offer))

if offer in self.service.observationOfferingList:

propertiesList = QStringListCheckableModel(self.service[offer].observableProperties)

propertiesList.dataChanged.connect(self.updateLayerName)

self.lstProperties.setModel(propertiesList)

operationsMetadata = self.service.operationsMetadata

featureOfInterestList= []

if operationsMetadata:

getFoIOp = operationsMetadata['GetFeatureOfInterest']

if getFoIOp:

featureOfInterestList = getFoIOp.parameters['featureOfInterest']

featuresList = QStringListCheckableModel(featureOfInterestList)

featuresList.dataChanged.connect(self.featuresSelectedChange)

self.lstFeatures.setModel(featuresList)

procedureList = []

procedureList.append(self.service[offer].procedure)

self.lstProcedures.setModel(QStringListCheckableModel(procedureList))

self.cmbFilterScalarOperands.setModel(QtGui.QStringListModel(self.service[offer].observableProperties))

self.filterRequest.scalarOperand = self.service[offer].observableProperties[0]

self.srsName = self.service[offer].srsName

#self.cmbResultModel.setModel(QtGui.QStringListModel(self.service[offer].resultModel)) # TODO: ?

self.updateLayerName ()

def updateLayerName (self):

if not len(self.layerName.text()) or self.layerName.text() == self.lastLayerName:

self.lastLayerName = self.selectedOffering

properties = ",".join(self.selectedProperties)

if len(properties):

self.lastLayerName += ": " + properties

self.layerName.setText(self.lastLayerName)

else:

self.lastLayerName = ""

self.layerName.setText(self.lastLayerName)

def featuresSelectedChange (self):

if len(self.selectedFeaturesOfInterest) > 0 and \

not self.lblSpatialFilterWarning.isVisibleTo(self.lblSpatialFilterWarning.parent()) and \

self.grpFilterSpatial.isChecked():

self.messageBar.pushMessage(self.lblSpatialFilterWarning.text(),QgsMessageBar.WARNING,10)

self.lblSpatialFilterWarning.setVisible (len(self.selectedFeaturesOfInterest) > 0)

def executeRequest (self, url, callback, post = None):

self.messageBar.clearWidgets()

self.cmbOfferings.setEnabled (False)

self.tabWidget.setEnabled (False)

if post:

request = QNetworkRequest(url)

request.setRawHeader('Content-Type', 'application/xml')

self.reply = QgsNetworkAccessManager.instance().post(request,post)

else:

self.reply = QgsNetworkAccessManager.instance().get(QNetworkRequest(url))

progressMessageBar = self.messageBar.createMessage(self.tr("Please wait while downloading"))

progressBar = QtGui.QProgressBar(self)

progressBar.setMinimum(0)

progressBar.setFormat(self.tr("%v bytes downloaded!"))

progressBar.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)

def updateProgress (read, total):

try:

progressBar.setMaximum (total)

progressBar.setValue (read)

except: pass

updateProgress (0,0)

self.reply.downloadProgress.connect (updateProgress)

progressMessageBar.layout().addWidget(progressBar)

btnAbort = QtGui.QPushButton(self.tr("Abort"))

btnAbort.clicked.connect(self.reply.abort)

progressMessageBar.layout().addWidget(btnAbort)

fd, replyFilename = mkstemp(suffix=".xml", prefix = callback.__name__, dir = self.selectedWorkDir())

os.close(fd)

replyFile = open (replyFilename, "w")

def replyReadyRead ():

try: replyFile.write (self.reply.readAll())

except: pass

self.reply.readyRead.connect(replyReadyRead)

def finishRequest ():

replyFile.close()

self.cmbOfferings.setEnabled (True)

self.tabWidget.setEnabled(True)

self.messageBar.clearWidgets()

if self.reply.error() != QNetworkReply.NoError:

self.messageBar.pushMessage(self.reply.errorString(), QgsMessageBar.CRITICAL)

else:

callback(replyFilename)

self.reply.deleteLater()

self.reply.finished.connect(finishRequest)

self.messageBar.pushWidget(progressMessageBar, QgsMessageBar.INFO)

def capabilitiesRequest (self, fileName):

try:

self.service = SensorObservationService (self.reply.url(), fileName)

self.filterRequest = FilterRequest (self.service)

except Exception as error:

self.service = None

widget = self.messageBar.createMessage(unicode(error))

button = QtGui.QCommandLinkButton (widget)

button.setText(self.tr("Show reply"))

button.clicked.connect(XmlViewerDialog (self, QtCore.QFile(fileName), XmlHighlighter).exec_)

widget.layout().addWidget(button)

self.messageBar.pushWidget(widget, QgsMessageBar.CRITICAL)

if self.service:

self.messageBar.pushMessage(self.tr("Capabilities downloaded"),QgsMessageBar.INFO,3)

self.htmlView.setText (unicode(self.service))

for offer in self.service.observationOfferingList:

self.cmbOfferings.addItem("%s (%s)" % (self.service[offer].identifier,self.service[offer].identifier), self.service[offer].identifier)

index = self.cmbOfferings.currentIndex()

if index > -1: self.cmbOfferings.activated.emit(index)

if 'GetObservation' in self.service.operationsMetadata:

self.btnAdd.setEnabled(True)

self.grpFilterSpatial.setChecked (self.filterRequest.spatialFilter == True)

self.grpFilterSpatial.setEnabled (self.filterRequest.spatialFilter != None)

self.cmbFilterSpatialOperators.setModel(QtGui.QStringListModel(self.service.spatialOperators))

self.cmbFilterSpatialOperands.setModel(QtGui.QStringListModel(self.service.spatialOperands))

self.cmbFilterSpatialOperands.activated.emit(self.cmbFilterSpatialOperands.currentIndex())

self.grpFilterTemporal.setChecked (self.filterRequest.temporalFilter == True)

self.grpFilterTemporal.setEnabled (self.filterRequest.temporalFilter != None)

self.cmbFilterTemporalOperators.setModel(QtGui.QStringListModel(self.service.temporalOperators))

self.cmbFilterTemporalOperands.setModel(QtGui.QStringListModel(self.service.temporalOperands))

self.cmbFilterTemporalOperands.activated.emit(self.cmbFilterTemporalOperands.currentIndex())

self.grpFilterScalar.setChecked (self.filterRequest.temporalFilter == True)

self.grpFilterScalar.setEnabled (self.filterRequest.temporalFilter != None)

self.cmbFilterScalarOperators.setModel(QtGui.QStringListModel(self.service.scalarOperators))

self.cmbFilterScalarOperators.activated.emit(self.cmbFilterScalarOperators.currentIndex())

@QtCore.pyqtSlot()

def on_actionShowXML_triggered(self):

try: XmlViewerDialog (self, self.service.capabilitiesXml, XmlHighlighter).exec_()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectAllProperties_triggered(self):

try: self.lstProperties.model().checkAll()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectNoneProperties_triggered(self):

try: self.lstProperties.model().checkNone()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectInvertProperties_triggered(self):

try: self.lstProperties.model().checkInvert()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectAllFeatures_triggered(self):

try: self.lstFeatures.model().checkAll()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectNoneFeatures_triggered(self):

try: self.lstFeatures.model().checkNone()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectInvertFeatures_triggered(self):

try: self.lstFeatures.model().checkInvert()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectAllProcedures_triggered(self):

try: self.lstProcedures.model().checkAll()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectNoneProcedures_triggered(self):

try: self.lstProcedures.model().checkNone()

except: pass

@QtCore.pyqtSlot()

def on_actionSelectInvertProcedures_triggered(self):

try: self.lstProcedures.model().checkInvert()

except: pass

@QtCore.pyqtSlot(bool)

def on_grpFilterSpatial_toggled (self, check):

self.filterRequest.spatialFilter = check

QgsDebug ("FilterRequest: " + str(self.filterRequest))

@QtCore.pyqtSlot(int)

def on_cmbFilterSpatialOperators_activated(self, index):

self.filterRequest.spatialOperator = self.cmbFilterSpatialOperators.currentText() if index > -1 else ""

@QtCore.pyqtSlot(int)

def on_cmbFilterSpatialOperands_activated(self, index):

self.filterRequest.spatialOperand = self.cmbFilterSpatialOperands.currentText() if index > -1 else ""

opWidget = self.laySpatialFilter.takeAt(1)

if (opWidget):

self.laySpatialFilter.removeItem(opWidget)

opWidget.widget().deleteLater()

opWidget = QLineEditButton (icon = QtGui.QIcon(":/plugins/SOSClient/coordinate_capture.png"))

opWidget.setPlaceholderText(self.filterRequest.spatialOperand)

opWidget.buttonClicked.connect(self.mapSelectionTool)

self.laySpatialFilter.addWidget (opWidget)

opWidget.editingFinished.connect(self.spatialValueChanged)

def mapSelectionTool(self):

self.hide()

QgsDebug ("mapSelectionTool " + self.filterRequest.spatialOperand)

tool = QgsMapToolCaptureSpatialOperand(self.iface.mapCanvas(), self.filterRequest.spatialOperand, self.srsName, self.sender())

tool.selectionFinished.connect(self.mapSelectionToolFinished)

self.iface.mapCanvas().setMapTool(tool)

def mapSelectionToolFinished (self, wkt):

tool = self.sender()

if wkt: tool.parent.setText (wkt)

tool.parent.editingFinished.emit()

tool.selectionFinished.disconnect(self.mapSelectionToolFinished)

tool.deactivate()

del tool

self.show()

@QtCore.pyqtSlot(bool)

def on_grpFilterTemporal_toggled (self, check):

self.filterRequest.temporalFilter = check

QgsDebug ("FilterRequest: " + str(self.filterRequest))

@QtCore.pyqtSlot(int)

def on_cmbFilterTemporalOperators_activated(self, index):

self.filterRequest.temporalOperator = self.cmbFilterTemporalOperators.currentText() if index > -1 else ""

@QtCore.pyqtSlot(int)

def on_cmbFilterTemporalOperands_activated(self, index):

self.filterRequest.temporalOperand = self.cmbFilterTemporalOperands.currentText() if index > -1 else ""

opWidget = self.layTemporalFilter.takeAt(1)

if (opWidget):

self.layTemporalFilter.removeItem(opWidget)

opWidget.widget().deleteLater()

if self.filterRequest.temporalOperand == "gml:TimePeriod":

opWidget = TimePeriodWidget()

else:

opWidget = TimeWidget()

self.filterRequest.temporalValue = opWidget.text()

self.layTemporalFilter.addWidget (opWidget)

opWidget.editingFinished.connect(self.temporalValueChanged)

@QtCore.pyqtSlot(bool)

def on_grpFilterScalar_toggled (self, check):

self.filterRequest.scalarFilter = check

QgsDebug ("FilterRequest: " + str(self.filterRequest))

@QtCore.pyqtSlot(int)

def on_cmbFilterScalarOperators_activated(self, index):

self.filterRequest.scalarOperator = self.cmbFilterScalarOperators.currentText() if index > -1 else ""

opWidget = self.layScalarFilter.takeAt(1)

if (opWidget):

self.layScalarFilter.removeItem(opWidget)

opWidget.widget().deleteLater()

opWidget = QtGui.QLineEdit()

opWidget.setPlaceholderText(self.filterRequest.scalarOperator)

self.layScalarFilter.addWidget (opWidget)

opWidget.editingFinished.connect(self.scalarValueChanged)

@QtCore.pyqtSlot(int)

def on_cmbFilterScalarOperands_activated(self, index):

self.filterRequest.scalarOperand = self.cmbFilterScalarOperands.currentText() if index > -1 else ""

@QtCore.pyqtSlot()

def spatialValueChanged (self):

widget = self.sender()

self.filterRequest.spatialValue = widget.text()

widget.blockSignals(True)

widget.setText (self.filterRequest.spatialValue)

widget.blockSignals(False)

@QtCore.pyqtSlot()

def temporalValueChanged (self):

widget = self.sender()

self.filterRequest.temporalValue = widget.text()

widget.blockSignals(True)

widget.setText (str(self.filterRequest.temporalValue))

widget.blockSignals(False)

@QtCore.pyqtSlot()

def scalarValueChanged (self):

widget = self.sender()

self.filterRequest.scalarValue = widget.text()

widget.blockSignals(True)

widget.setText (str(self.filterRequest.scalarValue))

widget.blockSignals(False)

@QtCore.pyqtSlot (bool)

def on_chkTimeManager_toggled (self, checked):

if checked:

if self.addLayerToTimeManager.__name__ == '<lambda>':

try:

from timemanager.timemanager import timemanager

from timemanager.timevectorlayer import TimeVectorLayer

from timemanager.layer_settings import LayerSettings

def addTimeVectorLayer (layer, iface=self.iface):

ls = LayerSettings ()

ls.layer = layer

ls.layerName = layer.name()

ls.layerId = layer.id()

ls.startTimeAttribute = 'time'

ls.endTimeAttribute = 'time'

timeLayerManager = timemanager(iface).getController().getTimeLayerManager()

timeLayerManager.registerTimeLayer(TimeVectorLayer(ls))

self.addLayerToTimeManager = addTimeVectorLayer

except ImportError:

self.messageBar.pushMessage(self.tr("TimeManager plugin is not instaled"), QgsMessageBar.WARNING, 5)

self.chkTimeManager.setChecked(False)

self.createTimeManagerLayer = checked

@QtCore.pyqtSlot()

def on_actionAdd_triggered(self):

if self.service:

self.executeRequest(self.service.getObservationsUrl,

self.observationsRequest,

self.service.getObservations(offering = self.selectedOffering,

properties = self.selectedProperties,

features = self.selectedFeaturesOfInterest,

procedures = self.selectedProcedures,

filters = self.filterRequest,

resultModel = self.selectedResultModel))

@QtCore.pyqtSlot()

def on_actionEditRequest_triggered(self):

if self.service:

dlg = TextEditDialog (self,

self.service.getObservations(offering = self.selectedOffering,

properties = self.selectedProperties,

features = self.selectedFeaturesOfInterest,

procedures = self.selectedProcedures,

filters = self.filterRequest,

resultModel = self.selectedResultModel),

XmlHighlighter)

if dlg.exec_():

self.executeRequest(self.service.getObservationsUrl, self.observationsRequest, dlg.text)

def observationsRequest (self, fileName):

try:

layer = ObservationsLayer (self.layerName.text(), fileName, only1stGeo = self.rdoFirstObsGeo.isChecked())

def layerFinished ():

if progressBar:

self.iface.mainWindow().statusBar().removeWidget(progressBar)

progressBar.deleteLater()

layer.moveToThread(QtGui.QApplication.instance().thread())

if thread:

thread.deleteLater()

if not layer.vectorLayer.isValid():

widget = self.messageBar.createMessage(layer.error)

button = QtGui.QCommandLinkButton (widget)

button.setText(self.tr("Show reply"))

button.clicked.connect(XmlViewerDialog (self, QtCore.QFile(fileName), XmlHighlighter).exec_)

widget.layout().addWidget(button)

self.messageBar.pushWidget(widget, QgsMessageBar.CRITICAL)

else :

QgsMapLayerRegistry.instance().addMapLayer(layer.vectorLayer)

if self.createTimeManagerLayer:

self.addLayerToTimeManager (layer.vectorLayer)

progressBar = QtGui.QProgressBar(self)

self.iface.mainWindow().statusBar().insertWidget(0, progressBar)

progressBar.setToolTip(layer.name)

progressBar.setRange(0,0)

progressBar.setVisible (True)

thread = QtCore.QThread(self)

layer.moveToThread(thread)

thread.started.connect (layer.toVectorLayer)

layer.finished.connect (layerFinished, QtCore.Qt.QueuedConnection)

thread.start()

except Exception as error:

widget = self.messageBar.createMessage(unicode(error))

button = QtGui.QCommandLinkButton (widget)

button.setText(self.tr("Show reply"))

button.clicked.connect(XmlViewerDialog (self, QtCore.QFile(fileName), XmlHighlighter).exec_)

widget.layout().addWidget(button)

self.messageBar.pushWidget(widget, QgsMessageBar.CRITICAL)

if thread: