def __init__(self, iface):
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = QtCore.QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path() + "/python/plugins/DataDrivenInputMask"
self.app = QgsApplication.instance()
try:
self.app.ddManager
except AttributeError:
ddManager = DdManager(self.iface)
self.app.ddManager = ddManager
# initialize locale
localePath = ""
locale = QtCore.QSettings().value("locale/userLocale")[0:2]
libPath = os.path.dirname(__file__)
libPathFound = False
for p in sys.path:
if p == libPath:
libPathFound = True
break
if not libPathFound:
sys.path.append(libPath)
if QtCore.QFileInfo(self.plugin_dir).exists():
localePath = self.plugin_dir + "/i18n/datadriveninputmask_" + locale + ".qm"
if QtCore.QFileInfo(localePath).exists():
self.translator = QtCore.QTranslator()
self.translator.load(localePath)
if QtCore.qVersion() > '4.3.3':
QtCore.QCoreApplication.installTranslator(self.translator)
class ExplorerDialog(QtWidgets.QDockWidget, Ui_ExplorerDialog):
layerChanged = QtCore.pyqtSignal()
refreshLayers = QtCore.pyqtSignal()
attributesLoaded = QtCore.pyqtSignal(int)
dependentChanged = QtCore.pyqtSignal()
chartChanged = QtCore.pyqtSignal()
addSelection = QtCore.pyqtSignal(bool)
showLinesChanged = QtCore.pyqtSignal(bool)
def __init__(self, parent):
QtWidgets.QDockWidget.__init__(self, parent)
# Set up the user interface from Designer.
self.setupUi(self)
# global variables
self.layer_attributes = {}
self.curr_attribute = 0
self.attribute_min = 0.0
self.attribute_max = 0.0
self.symbology_settings = []
self.chart_settings = []
self.curr_chart = 0
# default symbology values
self.colourRangeCombo.addItems(
["Classic", "Red - blue", "Greyscale",
"Monochrome"]) # "Classic inflection"
self.intervalTypeCombo.addItems([
"Equal intervals", "Quantiles", "Natural breaks", "Custom (Equal)"
]) # "Default NACh"
# self.layerRefreshButton.hide()
self.current_symbology = dict()
# self.__clearSymbology()
# statistics labels
self.__addStatsLabels()
self.statisticsProgressBar.hide()
# charts widgets
self.pLabel.hide()
self.chartsProgressBar.hide()
self.histogramCheck.setChecked(True)
self.lineCheck.setChecked(True)
self.__lockDependentGroup(True)
# add a pyqtgraph Plotwidget if the package is available, otherwise use a plain graphics view for painting on
if has_pyqtgraph:
self.chartPlotWidget = pg.PlotWidget(self.chartsTab)
self.chartPlotWidget.enableAutoRange()
# Enable/disable antialiasing for prettier plots, but much slower
pg.setConfigOptions(antialias=False)
else:
self.chartPlotWidget = QtWidgets.QGraphicsView(self.chartsTab)
self.chartPlotWidget.setFrameShape(QtWidgets.QFrame.NoFrame)
self.chartPlotWidget.setFrameShadow(QtWidgets.QFrame.Sunken)
self.chartPlotWidget.setObjectName("chartPlotWidget")
self.chartsLayout.addWidget(self.chartPlotWidget)
self.chartsLayout.setStretch(1, 1)
# Connect dialog's internal signals and slots
# self.attributesLoaded.connect(self.__lockColourControls)
self.layerRefreshButton.clicked.connect(self.__refreshLayers)
self.layerCombo.activated.connect(self.__selectCurrentLayer)
self.attributesList.currentRowChanged.connect(self.__lockApplyButton)
self.attributesList.currentRowChanged.connect(
self.__selectCurrentAttribute)
# symbology colour range settings
self.colourRangeCombo.currentIndexChanged.connect(
self.__colourRangeSelected)
self.lineWidthSpin.valueChanged.connect(self.__lineWidthChanged)
self.invertColourCheck.stateChanged.connect(self.__invertColourChanged)
self.displayOrderCombo.currentIndexChanged.connect(
self.__displayOrderSelected)
# symbology interval settings
self.intervalSpin.valueChanged.connect(self.__intervalNumberChanged)
self.intervalTypeCombo.activated.connect(self.__intervalTypeChanged)
self.topLimitSpin.valueChanged.connect(self.__topLimitSpinClicked)
self.topLimitText.editingFinished.connect(self.__topLimitTextChanged)
self.bottomLimitSpin.valueChanged.connect(
self.__bottomLimitSpinClicked)
self.bottomLimitText.editingFinished.connect(
self.__bottomLimitTextChanged)
# charts
self.histogramCheck.clicked.connect(self.__histogramSelected)
self.scatterplotCheck.clicked.connect(self.__scatterplotSelected)
self.yaxisCombo.currentIndexChanged.connect(self.yAxisChanged)
self.lineCheck.stateChanged.connect(self.__extraLinesChanged)
#####
# General functions of the explorer dialog
def keyPressEvent(self, QKeyEvent):
if QKeyEvent.key() == QtCore.Qt.Key_Shift:
self.addSelection.emit(True)
def keyReleaseEvent(self, QKeyEvent):
if QKeyEvent.key() == QtCore.Qt.Key_Shift:
self.addSelection.emit(False)
# Layer and attributes group
#
def __refreshLayers(self):
self.refreshLayers.emit()
def setCurrentLayer(self, names, idx=0):
# block the signal to update the attributes to avoid repeat updates when there is a layer selected
# self.layerCombo.blockSignals(True)
self.layerCombo.clear()
self.layerCombo.addItems(names)
self.layerCombo.setCurrentIndex(idx)
# self.layerCombo.blockSignals(False)
if idx == 0:
self.__selectCurrentLayer()
def __selectCurrentLayer(self):
self.layerChanged.emit()
def getCurrentLayer(self):
return self.layerCombo.currentText()
def getCurrentTab(self):
return self.explorerTabs.currentIndex()
def lockLayerRefresh(self, onoff):
self.layerRefreshButton.setDisabled(onoff)
def setAttributesList(self, data):
self.layer_attributes = data
self.attributesList.blockSignals(True)
self.attributesList.clear()
if len(data) > 0:
# get the names for the list
names = [attr['name'] for attr in self.layer_attributes]
self.attributesList.addItems(names)
self.__setYAxisCombo(names)
self.__lockColourControls(False)
else:
self.__setYAxisCombo([])
# self.clearPlot()
self.__lockColourControls(True)
# self.attributesLoaded.emit(self.attributesList.count())
self.attributesList.blockSignals(False)
def setAttributesSymbology(self, data):
self.symbology_settings = data
def setCurrentAttribute(self, idx):
self.attributesList.setCurrentRow(idx)
def getCurrentAttribute(self):
return self.attributesList.currentRow()
def __selectCurrentAttribute(self):
self.curr_attribute = self.attributesList.currentRow()
if self.curr_attribute >= 0:
self.__loadDisplaySettings()
def __loadDisplaySettings(self):
attribute = self.layer_attributes[self.curr_attribute]
self.attribute_max = attribute['max']
self.attribute_min = attribute['min']
# get current display settings
settings = self.symbology_settings[self.curr_attribute]
for key in settings.keys():
self.current_symbology[key] = settings[key]
# update the interface
self.setColourRanges(int(self.current_symbology['colour_range']))
self.setLineWidthSpin(float(self.current_symbology['line_width']))
self.setInvertColour(int(self.current_symbology['invert_colour']))
self.setDisplayOrder(int(self.current_symbology['display_order']))
self.setIntervalSpin(int(self.current_symbology['intervals']))
self.setIntervalType(int(self.current_symbology['interval_type']))
self.setTopLimitSpin(
abs(uf.convertNumeric(self.current_symbology['top_percent'])))
self.setTopLimitText(str(self.current_symbology['top_value']))
self.setBottomLimitSpin(
abs(uf.convertNumeric(self.current_symbology['bottom_percent'])))
self.setBottomLimitText(str(self.current_symbology['bottom_value']))
def __clearSymbology(self):
# set default current display settings
self.current_symbology = dict(attribute="",
colour_range=0,
line_width=0.25,
invert_colour=0,
display_order=0,
intervals=10,
interval_type=0,
top_percent=100,
top_value=0.0,
bottom_percent=0,
bottom_value=0.0)
self.attribute_max = 0.0
self.attribute_min = 0.0
# update the interface
self.setColourRanges(int(self.current_symbology['colour_range']))
self.setLineWidthSpin(float(self.current_symbology['line_width']))
self.setInvertColour(int(self.current_symbology['invert_colour']))
self.setDisplayOrder(int(self.current_symbology['display_order']))
self.setIntervalSpin(int(self.current_symbology['intervals']))
self.setIntervalType(int(self.current_symbology['interval_type']))
self.setTopLimitSpin(
abs(uf.convertNumeric(self.current_symbology['top_percent'])))
self.setTopLimitText(str(self.current_symbology['top_value']))
self.setBottomLimitSpin(
abs(uf.convertNumeric(self.current_symbology['bottom_percent'])))
self.setBottomLimitText(str(self.current_symbology['bottom_value']))
def getUpdatedDisplaySettings(self):
settings = dict()
for key in self.current_symbology.keys():
settings[key] = self.current_symbology[key]
return settings
def lockTabs(self, onoff):
self.explorerTabs.setDisabled(onoff)
self.__clearSymbology()
self.__clearStats()
self.clearPlot()
# Symbology group
#
def __lockApplyButton(self, onoff):
if not onoff and self.current_symbology[
'top_value'] is not None and self.current_symbology[
'bottom_value'] is not None:
self.symbologyApplyButton.setDisabled(onoff)
else:
self.symbologyApplyButton.setDisabled(True)
def __lockColourControls(self, onoff):
# set all the colour and interval controls
if self.attributesList.count(
) == 0 or self.current_symbology['colour_range'] == 0:
self.colourRangeCombo.setDisabled(onoff)
self.invertColourCheck.setDisabled(onoff)
self.displayOrderCombo.setDisabled(onoff)
self.lineWidthSpin.setDisabled(onoff)
self.intervalSpin.setDisabled(onoff)
self.intervalTypeCombo.setDisabled(onoff)
if onoff == True or self.current_symbology['interval_type'] == 3:
self.__lockCustomIntervalControls(onoff)
self.__lockApplyButton(onoff)
def __lockCustomIntervalControls(self, onoff):
self.topLimitLabel.setDisabled(onoff)
self.topLimitSpin.setDisabled(onoff)
self.topLimitText.setDisabled(onoff)
self.bottomLimitLabel.setDisabled(onoff)
self.bottomLimitSpin.setDisabled(onoff)
self.bottomLimitText.setDisabled(onoff)
# Colour settings
def setColourRanges(self, idx):
if -1 < idx <= self.colourRangeCombo.maxVisibleItems():
self.colourRangeCombo.setCurrentIndex(idx)
self.__colourRangeSelected(idx)
def __colourRangeSelected(self, idx):
self.current_symbology['colour_range'] = idx
if idx > 4:
self.__lockColourControls(True)
else:
self.__lockColourControls(False)
def setLineWidthSpin(self, value):
self.lineWidthSpin.setValue(value)
def __lineWidthChanged(self, value):
self.current_symbology['line_width'] = value
def setInvertColour(self, onoff):
self.invertColourCheck.setChecked(onoff)
def __invertColourChanged(self, onoff):
if onoff:
self.current_symbology['invert_colour'] = 1
else:
self.current_symbology['invert_colour'] = 0
def setDisplayOrder(self, idx):
self.displayOrderCombo.setCurrentIndex(idx)
# self.__displayOrderSelected(idx)
def __displayOrderSelected(self, idx):
self.current_symbology['display_order'] = idx
# Interval settings
def setIntervalSpin(self, value):
self.intervalSpin.setValue(value)
def __intervalNumberChanged(self, value):
self.current_symbology['intervals'] = value
def setIntervalType(self, idx):
if -1 < idx <= self.intervalTypeCombo.maxVisibleItems():
self.intervalTypeCombo.setCurrentIndex(idx)
self.__intervalTypeChanged(idx)
def __intervalTypeChanged(self, idx):
self.current_symbology['interval_type'] = idx
if self.current_symbology['interval_type'] == 3:
if self.attribute_max == 'NULL' or self.attribute_min == 'NULL':
self.__lockCustomIntervalControls(True)
else:
self.__lockCustomIntervalControls(False)
if self.current_symbology[
'top_value'] is None and self.current_symbology[
'top_value'] is None:
self.__lockApplyButton(True)
else:
self.__lockApplyButton(False)
else:
self.__lockCustomIntervalControls(True)
if self.current_symbology['interval_type'] == 4:
# implementation of default NACh ranges used by Bill Hillier and SSx Ltd
self.setTopLimitText("1.4")
self.__topLimitTextChanged()
self.setBottomLimitText("0.8")
self.__bottomLimitTextChanged()
# else:
# self.current_symbology["top_value"] = self.attribute_max
# self.current_symbology["bottom_value"] = self.attribute_min
self.__lockApplyButton(False)
def __topLimitSpinClicked(self, value):
self.current_symbology['top_percent'] = value
if value < 100:
# calculate spin absolute value
spin = ((self.attribute_max - self.attribute_min) *
self.current_symbology['top_percent'] /
100) + self.attribute_min
else:
spin = self.attribute_max
self.setTopLimitText(str(spin))
self.bottomLimitSpin.setMaximum(value)
self.__lockApplyButton(False)
def setTopLimitText(self, txt):
self.topLimitText.blockSignals(True)
self.topLimitText.clear()
self.topLimitText.setText(txt)
self.current_symbology['top_value'] = float(txt)
self.topLimitText.blockSignals(False)
def __topLimitTextChanged(self):
value = self.topLimitText.text()
if uf.isNumeric(value):
self.current_symbology['top_value'] = float(value)
if self.current_symbology['top_value'] >= self.current_symbology[
'bottom_value'] and self.current_symbology[
'top_value'] <= self.attribute_max:
# calculate spin percentage
spin = abs(
((self.current_symbology['top_value'] - self.attribute_min)
/ (self.attribute_max - self.attribute_min)) * 100)
self.setTopLimitSpin(spin)
self.bottomLimitSpin.setMaximum(spin)
self.__lockApplyButton(False)
else:
self.current_symbology['top_value'] = None
self.__lockApplyButton(True)
else:
self.current_symbology['top_value'] = None
self.__lockApplyButton(True)
def setTopLimitSpin(self, value):
self.topLimitSpin.blockSignals(True)
self.topLimitSpin.setValue(value)
self.current_symbology['top_percent'] = value
self.topLimitSpin.blockSignals(False)
def __bottomLimitSpinClicked(self, value):
self.current_symbology['bottom_percent'] = value
if value > 0:
# calculate spin absolute value
spin = ((self.attribute_max - self.attribute_min) *
self.current_symbology['bottom_percent'] /
100) + self.attribute_min
else:
spin = self.attribute_min
self.setBottomLimitText(str(spin))
self.topLimitSpin.setMinimum(value)
self.__lockApplyButton(False)
def setBottomLimitText(self, txt):
self.bottomLimitText.blockSignals(True)
self.bottomLimitText.clear()
self.bottomLimitText.setText(txt)
self.current_symbology['bottom_value'] = float(txt)
self.bottomLimitText.blockSignals(False)
def __bottomLimitTextChanged(self):
value = self.bottomLimitText.text()
if uf.isNumeric(value):
self.current_symbology['bottom_value'] = float(value)
if self.current_symbology['bottom_value'] <= self.current_symbology[
'top_value'] and self.current_symbology[
'bottom_value'] >= self.attribute_min:
# calculate spin percentage
spin = abs(((self.current_symbology['bottom_value'] -
self.attribute_min) /
(self.attribute_max - self.attribute_min)) * 100)
self.setBottomLimitSpin(spin)
self.topLimitSpin.setMinimum(spin)
self.__lockApplyButton(False)
else:
self.current_symbology['bottom_value'] = None
self.__lockApplyButton(True)
else:
self.current_symbology['bottom_value'] = None
self.__lockApplyButton(True)
def setBottomLimitSpin(self, value):
self.bottomLimitSpin.blockSignals(True)
self.bottomLimitSpin.setValue(value)
self.current_symbology['bottom_percent'] = value
self.bottomLimitSpin.blockSignals(False)
#
# Statistics group
#
def __addStatsLabels(self):
self.statisticsTable.setHorizontalHeaderLabels(
["Statistic", "Value", "Selection"])
self.statisticsTable.setRowCount(12)
self.statisticsTable.setItem(0, 0,
QtWidgets.QTableWidgetItem("Number"))
self.statisticsTable.setItem(1, 0, QtWidgets.QTableWidgetItem("Mean"))
self.statisticsTable.setItem(2, 0,
QtWidgets.QTableWidgetItem("Std Dev"))
self.statisticsTable.setItem(3, 0,
QtWidgets.QTableWidgetItem("Variance"))
self.statisticsTable.setItem(4, 0,
QtWidgets.QTableWidgetItem("Median"))
self.statisticsTable.setItem(5, 0,
QtWidgets.QTableWidgetItem("Minimum"))
self.statisticsTable.setItem(6, 0,
QtWidgets.QTableWidgetItem("Maximum"))
self.statisticsTable.setItem(7, 0, QtWidgets.QTableWidgetItem("Range"))
self.statisticsTable.setItem(8, 0,
QtWidgets.QTableWidgetItem("1st Quart"))
self.statisticsTable.setItem(9, 0,
QtWidgets.QTableWidgetItem("3rd Quart"))
self.statisticsTable.setItem(10, 0, QtWidgets.QTableWidgetItem("IQR"))
self.statisticsTable.setItem(11, 0, QtWidgets.QTableWidgetItem("Gini"))
def setStats(self, stats, selection):
# update the interface
for row in range(self.statisticsTable.rowCount()):
label = self.statisticsTable.item(row, 0).text()
if label in stats:
item = QtWidgets.QTableWidgetItem(str(stats[label]))
self.statisticsTable.setItem(row, 1, item)
if selection:
if label in selection:
item = QtWidgets.QTableWidgetItem(str(selection[label]))
self.statisticsTable.setItem(row, 2, item)
else:
self.statisticsTable.setItem(row, 2,
QtWidgets.QTableWidgetItem(""))
self.statisticsTable.horizontalHeader().setResizeMode(
0, QtWidgets.QHeaderView.ResizeToContents)
self.statisticsTable.horizontalHeader().setResizeMode(
1, QtWidgets.QHeaderView.Stretch)
self.statisticsTable.horizontalHeader().setResizeMode(
2, QtWidgets.QHeaderView.Stretch)
self.statisticsTable.resizeRowsToContents()
def __clearStats(self):
self.statisticsTable.clear()
self.__addStatsLabels()
self.statisticsProgressBar.setValue(0)
def setStatsProgressBar(self, value):
self.statisticsProgressBar.setValue(int(value))
#
# Charts group
#
def __lockDependentGroup(self, onoff):
self.yaxisCombo.setDisabled(onoff)
self.yaxisLabel.setDisabled(onoff)
self.rLabel.setDisabled(onoff)
self.pLabel.setDisabled(onoff)
self.r2Label.setDisabled(onoff)
self.lineLabel.setDisabled(onoff)
if onoff:
self.clearDependentValues()
self.lineCheck.setText("Selection lines")
else:
self.lineCheck.setText("Regression line")
def __histogramSelected(self):
self.__lockDependentGroup(True)
self.curr_chart = 0
self.clearPlot()
self.chartChanged.emit()
def __scatterplotSelected(self):
self.__lockDependentGroup(False)
self.curr_chart = 1
self.clearPlot()
self.chartChanged.emit()
def getChartType(self):
return self.curr_chart
def __setYAxisCombo(self, attributes):
self.yaxisCombo.clear()
self.yaxisCombo.addItems(attributes)
# for attr in attributes:
# self.yaxisCombo.addItem(attr,attr)
self.yaxisCombo.setCurrentIndex(0)
def __setYAxisTooltip(self, idx):
if idx > 0:
self.yaxisCombo.setToolTip(self.yaxisCombo.itemText(idx))
else:
self.yaxisCombo.setToolTip(
'Select y axis attribute of scatter plot.')
def yAxisChanged(self):
if self.curr_chart == 1:
self.yaxisCombo.setToolTip(
self.yaxisCombo.itemText(self.yaxisCombo.currentIndex()))
self.dependentChanged.emit()
def getYAxisAttribute(self):
return self.yaxisCombo.currentIndex()
def clearDependentValues(self):
self.rLabel.setText("r: ")
self.pLabel.setText("p: ")
self.r2Label.setText("r2: ")
self.lineLabel.setText("Y = ")
def setCorrelation(self, stats):
self.rLabel.setText("r: " + str(stats["r"]))
self.pLabel.setText("p: " + str(stats["p"]))
self.r2Label.setText("r2: " + str(stats["r2"]))
self.lineLabel.setText("Y = " + str(stats["line"]))
def __extraLinesChanged(self, onoff):
self.showLinesChanged.emit(onoff)
def clearPlot(self):
if has_pyqtgraph:
self.chartPlotWidget.clear()
def qInitResources():
QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
def qCleanupResources():
QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
\x00\x00\x01\x53\x8c\x29\xb3\x0e\
\x00\x00\x00\xcc\x00\x00\x00\x00\x00\x01\x00\x00\x0e\x39\
\x00\x00\x01\x53\x8c\x29\xb3\x0e\
\x00\x00\x01\x2a\x00\x00\x00\x00\x00\x01\x00\x00\x18\xbf\
\x00\x00\x01\x53\x8c\x29\xb3\x0e\
\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x01\x00\x00\x08\x7d\
\x00\x00\x01\x53\x8c\x29\xb3\x0e\
\x00\x00\x01\x0e\x00\x00\x00\x00\x00\x01\x00\x00\x15\x86\
\x00\x00\x01\x53\x8c\x29\xb3\x0e\
\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x01\x00\x00\x04\xc4\
\x00\x00\x01\x53\x8c\x29\xb3\x0e\
\x00\x00\x00\xde\x00\x00\x00\x00\x00\x01\x00\x00\x10\x87\
\x00\x00\x01\x53\x8c\x29\xb3\x0e\
"
qt_version = QtCore.qVersion().split('.')
if qt_version < ['5', '8', '0']:
rcc_version = 1
qt_resource_struct = qt_resource_struct_v1
else:
rcc_version = 2
qt_resource_struct = qt_resource_struct_v2
def qInitResources():
QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
def qCleanupResources():
QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
qInitResources()
def path(self):
return QtCore.QRegularExpression(r"/handlertwo/(?P<code1>\d{2})/(\d{3})")
def _build_search_query(
self, search_params: models.GeonodeApiSearchFilters
) -> QtCore.QUrlQuery:
query = QtCore.QUrlQuery()
query.addQueryItem("page", str(search_params.page))
query.addQueryItem("page_size", str(search_params.page_size))
if search_params.title is not None:
query.addQueryItem("filter{title.icontains}", search_params.title)
if search_params.abstract is not None:
query.addQueryItem("filter{abstract.icontains}", search_params.abstract)
if search_params.selected_keyword is not None:
query.addQueryItem(
"filter{keywords.name.icontains}", search_params.selected_keyword
)
if search_params.topic_category is not None:
query.addQueryItem(
"filter{category.identifier}", search_params.topic_category
)
if search_params.temporal_extent_start is not None:
query.addQueryItem(
"filter{temporal_extent_start.gte}",
search_params.temporal_extent_start.toString(QtCore.Qt.ISODate),
)
if search_params.temporal_extent_end is not None:
query.addQueryItem(
"filter{temporal_extent_end.lte}",
search_params.temporal_extent_end.toString(QtCore.Qt.ISODate),
)
if search_params.publication_date_start is not None:
query.addQueryItem(
"filter{date.gte}",
search_params.publication_date_start.toString(QtCore.Qt.ISODate),
)
if search_params.publication_date_end is not None:
query.addQueryItem(
"filter{date.lte}",
search_params.publication_date_end.toString(QtCore.Qt.ISODate),
)
# TODO revisit once the support for spatial extent is available on
# GeoNode API V2
if (
search_params.spatial_extent is not None
and not search_params.spatial_extent.isNull()
):
pass
if search_params.layer_types is None:
types = [
models.GeonodeResourceType.VECTOR_LAYER,
models.GeonodeResourceType.RASTER_LAYER,
models.GeonodeResourceType.MAP,
]
else:
types = list(search_params.layer_types)
is_vector = models.GeonodeResourceType.VECTOR_LAYER in types
is_raster = models.GeonodeResourceType.RASTER_LAYER in types
is_map = models.GeonodeResourceType.MAP in types
if is_vector and is_raster:
pass
elif is_vector:
query.addQueryItem("filter{subtype}", "vector")
elif is_raster:
query.addQueryItem("filter{subtype}", "raster")
else:
raise NotImplementedError
if search_params.ordering_field is not None:
ordering_field_value = self.get_ordering_filter_name(
search_params.ordering_field,
reverse_sort=search_params.reverse_ordering,
)
query.addQueryItem("sort[]", ordering_field_value)
return query
def get_layer_detail_url_endpoint(self, id_: int) -> QtCore.QUrl:
return QtCore.QUrl(f"{self.api_url}/datasets/{id_}/")
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# ***********************************************************************
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QtCore.QSettings().value("locale/userLocale")[0:2]
locale_path = os.path.join(self.plugin_dir, "i18n",
"posttelemac_{}.qm".format(locale))
if os.path.exists(locale_path):
# app=QApplication([''])
self.translator = QtCore.QTranslator()
# self.translator = QTranslator(app)
self.translator.load(locale_path)
QtCore.QCoreApplication.installTranslator(self.translator)
"""
if qVersion() > '4.3.3':
print 'ok'
QCoreApplication.installTranslator(self.translator)
#app.installTranslator(self.translator)
"""
# ***********************************************************************
self.pluginLayerType = None
self.addToRegistry()
self.slf = []
# Declare instance attributes
self.actions = []
self.menu = self.tr(u"&PostTelemac")
# TODO: We are going to let the user set this up in a future iteration
# toolbar
try:
from qgis.PyQt.QtGui import QToolBar
except:
from qgis.PyQt.QtWidgets import QToolBar
toolbars = self.iface.mainWindow().findChildren(QToolBar)
test = True
for toolbar1 in toolbars:
if toolbar1.windowTitle() == u"Telemac":
self.toolbar = toolbar1
test = False
break
if test:
self.toolbar = self.iface.addToolBar(u"Telemac")
self.toolbar.setObjectName(u"Telemac")
self.dlg_about = None
# Processing
if DOPROCESSING:
self.provider = PostTelemacProvider()
def __init__(self, parent, combos, coord=None):
if not coord:
coord = ["", None, None, ""]
super(LegalRestrictionsDialog, self).__init__(parent)
if platform.system() != "Linux":
font = QFont()
font.setFamily(u"Segoe UI Symbol")
self.setFont(font)
self.setupUi(self)
self.setModal(True)
self.restrict_dic = combos[0]
self.combo_accessrestrictions.setModel(
CustomComboBoxModel(
self, [None] +
sorted(list(combos[0].values()), key=lambda x: x.term_pt)))
self.combo_userestrictions.setModel(
CustomComboBoxModel(
self, [None] +
sorted(list(combos[0].values()), key=lambda x: x.term_pt)))
self.btn_cancel.clicked.connect(lambda: self.done(QDialog.Rejected))
self.btn_add.clicked.connect(lambda: self.done(QDialog.Accepted))
self.line_uselimitations.textChanged.connect(self.checkInput)
self.combo_accessrestrictions.currentIndexChanged.connect(
self.checkInput)
self.combo_userestrictions.currentIndexChanged.connect(self.checkInput)
self.line_otherrestrictions.textEdited.connect(self.checkInput)
self.line_uselimitations.setText(coord[0])
if coord[1] is not None:
buf = combos[0].get(coord[1].term, None)
if buf is not None:
self.combo_accessrestrictions.setCurrentIndex(
self.combo_accessrestrictions.findText(buf.term_pt))
if coord[2] is not None:
buf = combos[0].get(coord[2].term, None)
if buf is not None:
self.combo_userestrictions.setCurrentIndex(
self.combo_userestrictions.findText(buf.term_pt))
self.line_otherrestrictions.setText(coord[3])
self.checkInput()
tla.setupMandatoryField(None, self.line_uselimitations,
self.label_line_uselimitations,
u"Elemento Obrigatório.")
tla.setupMandatoryField(None, self.combo_accessrestrictions,
self.label_combo_accessrestrictions,
u"Elemento Obrigatório.")
tla.setupMandatoryField(None, self.combo_userestrictions,
self.label_combo_userestrictions,
u"Elemento Obrigatório.")
self.superParent = None
temp = self.parent()
while self.superParent is None:
if issubclass(type(temp), restrictionsPanel.Ui_restrictions):
self.superParent = temp
else:
temp = temp.parent()
for info in self.findChildren(qgui.QPushButton,
qcore.QRegExp('info_*')):
info.setIcon(qgui.QIcon(':/resourcesFolder/icons/help_icon.svg'))
info.setText('')
info.pressed.connect(self.printHelp)
def setupUi(self, QgisCloudPlugin):
QgisCloudPlugin.setObjectName("QgisCloudPlugin")
QgisCloudPlugin.resize(501, 703)
QgisCloudPlugin.setLocale(
QtCore.QLocale(QtCore.QLocale.English,
QtCore.QLocale.UnitedStates))
self.dockWidgetContents = QtWidgets.QWidget()
self.dockWidgetContents.setObjectName("dockWidgetContents")
self.gridLayout_3 = QtWidgets.QGridLayout(self.dockWidgetContents)
self.gridLayout_3.setObjectName("gridLayout_3")
self.tabWidget = QtWidgets.QTabWidget(self.dockWidgetContents)
self.tabWidget.setObjectName("tabWidget")
self.mapTab = QtWidgets.QWidget()
self.mapTab.setObjectName("mapTab")
self.gridLayout_4 = QtWidgets.QGridLayout(self.mapTab)
self.gridLayout_4.setObjectName("gridLayout_4")
self.logo_2 = QtWidgets.QLabel(self.mapTab)
self.logo_2.setAutoFillBackground(False)
self.logo_2.setPixmap(QtGui.QPixmap(":/plugins/qgiscloud/logo.png"))
self.logo_2.setScaledContents(False)
self.logo_2.setAlignment(QtCore.Qt.AlignCenter)
self.logo_2.setObjectName("logo_2")
self.gridLayout_4.addWidget(self.logo_2, 0, 0, 1, 1)
self.btnBackgroundLayer = QtWidgets.QToolButton(self.mapTab)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.btnBackgroundLayer.sizePolicy().hasHeightForWidth())
self.btnBackgroundLayer.setSizePolicy(sizePolicy)
self.btnBackgroundLayer.setPopupMode(
QtWidgets.QToolButton.InstantPopup)
self.btnBackgroundLayer.setToolButtonStyle(
QtCore.Qt.ToolButtonTextOnly)
self.btnBackgroundLayer.setArrowType(QtCore.Qt.NoArrow)
self.btnBackgroundLayer.setObjectName("btnBackgroundLayer")
self.gridLayout_4.addWidget(self.btnBackgroundLayer, 1, 0, 1, 1)
self.labelOpenLayersPlugin = QtWidgets.QLabel(self.mapTab)
self.labelOpenLayersPlugin.setWordWrap(True)
self.labelOpenLayersPlugin.setObjectName("labelOpenLayersPlugin")
self.gridLayout_4.addWidget(self.labelOpenLayersPlugin, 2, 0, 1, 1)
self.line_2 = QtWidgets.QFrame(self.mapTab)
self.line_2.setFrameShape(QtWidgets.QFrame.HLine)
self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line_2.setObjectName("line_2")
self.gridLayout_4.addWidget(self.line_2, 3, 0, 1, 1)
self.btnPublishMap = QtWidgets.QPushButton(self.mapTab)
self.btnPublishMap.setObjectName("btnPublishMap")
self.gridLayout_4.addWidget(self.btnPublishMap, 4, 0, 1, 1)
self.line_3 = QtWidgets.QFrame(self.mapTab)
self.line_3.setFrameShape(QtWidgets.QFrame.HLine)
self.line_3.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line_3.setObjectName("line_3")
self.gridLayout_4.addWidget(self.line_3, 5, 0, 1, 1)
self.widgetServices = QtWidgets.QWidget(self.mapTab)
self.widgetServices.setObjectName("widgetServices")
self.gridLayout = QtWidgets.QGridLayout(self.widgetServices)
self.gridLayout.setObjectName("gridLayout")
self.label = QtWidgets.QLabel(self.widgetServices)
self.label.setObjectName("label")
self.gridLayout.addWidget(self.label, 1, 0, 1, 1)
self.lblWMS = QtWidgets.QLabel(self.widgetServices)
self.lblWMS.setOpenExternalLinks(True)
self.lblWMS.setObjectName("lblWMS")
self.gridLayout.addWidget(self.lblWMS, 1, 1, 1, 1)
self.label_5 = QtWidgets.QLabel(self.widgetServices)
self.label_5.setObjectName("label_5")
self.gridLayout.addWidget(self.label_5, 2, 0, 1, 1)
self.lblMaps = QtWidgets.QLabel(self.widgetServices)
self.lblMaps.setOpenExternalLinks(True)
self.lblMaps.setObjectName("lblMaps")
self.gridLayout.addWidget(self.lblMaps, 2, 1, 1, 1)
self.label_8 = QtWidgets.QLabel(self.widgetServices)
self.label_8.setObjectName("label_8")
self.gridLayout.addWidget(self.label_8, 3, 0, 1, 1)
self.lblMobileMap_2 = QtWidgets.QLabel(self.widgetServices)
self.lblMobileMap_2.setEnabled(True)
self.lblMobileMap_2.setOpenExternalLinks(True)
self.lblMobileMap_2.setObjectName("lblMobileMap_2")
self.gridLayout.addWidget(self.lblMobileMap_2, 3, 1, 1, 1)
self.label_3 = QtWidgets.QLabel(self.widgetServices)
self.label_3.setObjectName("label_3")
self.gridLayout.addWidget(self.label_3, 0, 0, 1, 1)
self.lblWebmap = QtWidgets.QLabel(self.widgetServices)
self.lblWebmap.setOpenExternalLinks(True)
self.lblWebmap.setObjectName("lblWebmap")
self.gridLayout.addWidget(self.lblWebmap, 0, 1, 1, 1)
self.gridLayout_4.addWidget(self.widgetServices, 6, 0, 1, 1)
spacerItem = QtWidgets.QSpacerItem(20, 20,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Fixed)
self.gridLayout_4.addItem(spacerItem, 7, 0, 1, 1)
self.frame = QtWidgets.QFrame(self.mapTab)
self.frame.setEnabled(True)
self.frame.setFrameShape(QtWidgets.QFrame.NoFrame)
self.frame.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame.setLineWidth(1)
self.frame.setObjectName("frame")
self.gridLayout_6 = QtWidgets.QGridLayout(self.frame)
self.gridLayout_6.setObjectName("gridLayout_6")
self.widgetMaps = QtWidgets.QWidget(self.frame)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.widgetMaps.sizePolicy().hasHeightForWidth())
self.widgetMaps.setSizePolicy(sizePolicy)
self.widgetMaps.setObjectName("widgetMaps")
self.gridLayout_2 = QtWidgets.QGridLayout(self.widgetMaps)
self.gridLayout_2.setObjectName("gridLayout_2")
self.lblMaps_3 = QtWidgets.QLabel(self.widgetMaps)
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.lblMaps_3.setFont(font)
self.lblMaps_3.setObjectName("lblMaps_3")
self.gridLayout_2.addWidget(self.lblMaps_3, 0, 0, 1, 1)
self.tabMaps = QtWidgets.QListWidget(self.widgetMaps)
self.tabMaps.setObjectName("tabMaps")
self.gridLayout_2.addWidget(self.tabMaps, 1, 0, 1, 3)
self.btnMapLoad = QtWidgets.QPushButton(self.widgetMaps)
self.btnMapLoad.setObjectName("btnMapLoad")
self.gridLayout_2.addWidget(self.btnMapLoad, 2, 0, 1, 1)
self.btnMapDelete = QtWidgets.QPushButton(self.widgetMaps)
self.btnMapDelete.setEnabled(False)
self.btnMapDelete.setObjectName("btnMapDelete")
self.gridLayout_2.addWidget(self.btnMapDelete, 2, 1, 1, 1)
spacerItem1 = QtWidgets.QSpacerItem(145, 20,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.gridLayout_2.addItem(spacerItem1, 2, 2, 1, 1)
self.gridLayout_6.addWidget(self.widgetMaps, 0, 0, 1, 1)
self.gridLayout_4.addWidget(self.frame, 8, 0, 1, 1)
self.tabWidget.addTab(self.mapTab, "")
self.uploadTab = QtWidgets.QWidget()
self.uploadTab.setEnabled(True)
self.uploadTab.setObjectName("uploadTab")
self.verticalLayout_6 = QtWidgets.QVBoxLayout(self.uploadTab)
self.verticalLayout_6.setObjectName("verticalLayout_6")
self.horizontalLayout_3 = QtWidgets.QHBoxLayout()
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.label_10 = QtWidgets.QLabel(self.uploadTab)
self.label_10.setObjectName("label_10")
self.horizontalLayout_3.addWidget(self.label_10)
self.cbUploadDatabase = QtWidgets.QComboBox(self.uploadTab)
self.cbUploadDatabase.setObjectName("cbUploadDatabase")
self.horizontalLayout_3.addWidget(self.cbUploadDatabase)
self.verticalLayout_6.addLayout(self.horizontalLayout_3)
self.lblDbSizeUpload = QtWidgets.QLabel(self.uploadTab)
self.lblDbSizeUpload.setText("")
self.lblDbSizeUpload.setObjectName("lblDbSizeUpload")
self.verticalLayout_6.addWidget(self.lblDbSizeUpload)
self.tblLocalLayers = QtWidgets.QTableWidget(self.uploadTab)
self.tblLocalLayers.setSelectionBehavior(
QtWidgets.QAbstractItemView.SelectRows)
self.tblLocalLayers.setObjectName("tblLocalLayers")
self.tblLocalLayers.setColumnCount(0)
self.tblLocalLayers.setRowCount(0)
self.tblLocalLayers.horizontalHeader().setStretchLastSection(True)
self.tblLocalLayers.verticalHeader().setVisible(False)
self.verticalLayout_6.addWidget(self.tblLocalLayers)
self.horizontalLayout_7 = QtWidgets.QHBoxLayout()
self.horizontalLayout_7.setObjectName("horizontalLayout_7")
spacerItem2 = QtWidgets.QSpacerItem(40, 20,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.horizontalLayout_7.addItem(spacerItem2)
self.btnRefreshLocalLayers = QtWidgets.QPushButton(self.uploadTab)
self.btnRefreshLocalLayers.setObjectName("btnRefreshLocalLayers")
self.horizontalLayout_7.addWidget(self.btnRefreshLocalLayers)
self.verticalLayout_6.addLayout(self.horizontalLayout_7)
self.btnUploadData = QtWidgets.QPushButton(self.uploadTab)
self.btnUploadData.setObjectName("btnUploadData")
self.verticalLayout_6.addWidget(self.btnUploadData)
self.progressWidget = QtWidgets.QWidget(self.uploadTab)
self.progressWidget.setObjectName("progressWidget")
self.horizontalLayout_6 = QtWidgets.QHBoxLayout(self.progressWidget)
self.horizontalLayout_6.setObjectName("horizontalLayout_6")
self.spinner = Spinner(self.progressWidget)
self.spinner.setObjectName("spinner")
self.horizontalLayout_6.addWidget(self.spinner)
self.lblProgress = QtWidgets.QLabel(self.progressWidget)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.lblProgress.sizePolicy().hasHeightForWidth())
self.lblProgress.setSizePolicy(sizePolicy)
self.lblProgress.setText("")
self.lblProgress.setObjectName("lblProgress")
self.horizontalLayout_6.addWidget(self.lblProgress)
self.verticalLayout_6.addWidget(self.progressWidget)
self.tabWidget.addTab(self.uploadTab, "")
self.accountTab = QtWidgets.QWidget()
self.accountTab.setObjectName("accountTab")
self.gridLayout_5 = QtWidgets.QGridLayout(self.accountTab)
self.gridLayout_5.setObjectName("gridLayout_5")
self.horizontalLayout_4 = QtWidgets.QHBoxLayout()
self.horizontalLayout_4.setObjectName("horizontalLayout_4")
self.label_2 = QtWidgets.QLabel(self.accountTab)
self.label_2.setObjectName("label_2")
self.horizontalLayout_4.addWidget(self.label_2)
self.editServer = QtWidgets.QLineEdit(self.accountTab)
self.editServer.setEnabled(True)
self.editServer.setObjectName("editServer")
self.horizontalLayout_4.addWidget(self.editServer)
self.resetUrlBtn = QtWidgets.QToolButton(self.accountTab)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/plugins/qgiscloud/icon.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.resetUrlBtn.setIcon(icon)
self.resetUrlBtn.setObjectName("resetUrlBtn")
self.horizontalLayout_4.addWidget(self.resetUrlBtn)
self.gridLayout_5.addLayout(self.horizontalLayout_4, 0, 0, 1, 1)
self.horizontalLayout_5 = QtWidgets.QHBoxLayout()
self.horizontalLayout_5.setObjectName("horizontalLayout_5")
self.btnLogin = QtWidgets.QPushButton(self.accountTab)
self.btnLogin.setObjectName("btnLogin")
self.horizontalLayout_5.addWidget(self.btnLogin)
self.lblSignup = QtWidgets.QLabel(self.accountTab)
self.lblSignup.setAlignment(QtCore.Qt.AlignCenter)
self.lblSignup.setOpenExternalLinks(True)
self.lblSignup.setObjectName("lblSignup")
self.horizontalLayout_5.addWidget(self.lblSignup)
self.lblLoginStatus = QtWidgets.QLabel(self.accountTab)
self.lblLoginStatus.setObjectName("lblLoginStatus")
self.horizontalLayout_5.addWidget(self.lblLoginStatus)
spacerItem3 = QtWidgets.QSpacerItem(40, 20,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.horizontalLayout_5.addItem(spacerItem3)
self.btnLogout = QtWidgets.QPushButton(self.accountTab)
self.btnLogout.setObjectName("btnLogout")
self.horizontalLayout_5.addWidget(self.btnLogout)
self.gridLayout_5.addLayout(self.horizontalLayout_5, 1, 0, 1, 1)
self.widgetDatabases = QtWidgets.QWidget(self.accountTab)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.widgetDatabases.sizePolicy().hasHeightForWidth())
self.widgetDatabases.setSizePolicy(sizePolicy)
self.widgetDatabases.setObjectName("widgetDatabases")
self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.widgetDatabases)
self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_3.setObjectName("verticalLayout_3")
self.line = QtWidgets.QFrame(self.widgetDatabases)
self.line.setFrameShape(QtWidgets.QFrame.HLine)
self.line.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line.setObjectName("line")
self.verticalLayout_3.addWidget(self.line)
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.label_29 = QtWidgets.QLabel(self.widgetDatabases)
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.label_29.setFont(font)
self.label_29.setObjectName("label_29")
self.horizontalLayout_2.addWidget(self.label_29)
self.lblDbSize = QtWidgets.QLabel(self.widgetDatabases)
self.lblDbSize.setText("")
self.lblDbSize.setObjectName("lblDbSize")
self.horizontalLayout_2.addWidget(self.lblDbSize)
self.verticalLayout_3.addLayout(self.horizontalLayout_2)
self.tabDatabases = QtWidgets.QListWidget(self.widgetDatabases)
self.tabDatabases.setSelectionBehavior(
QtWidgets.QAbstractItemView.SelectRows)
self.tabDatabases.setObjectName("tabDatabases")
self.verticalLayout_3.addWidget(self.tabDatabases)
self.horizontalLayout = QtWidgets.QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.btnDbCreate = QtWidgets.QPushButton(self.widgetDatabases)
self.btnDbCreate.setObjectName("btnDbCreate")
self.horizontalLayout.addWidget(self.btnDbCreate)
self.btnDbDelete = QtWidgets.QPushButton(self.widgetDatabases)
self.btnDbDelete.setEnabled(False)
self.btnDbDelete.setObjectName("btnDbDelete")
self.horizontalLayout.addWidget(self.btnDbDelete)
spacerItem4 = QtWidgets.QSpacerItem(37, 17,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem4)
self.btnDbRefresh = QtWidgets.QPushButton(self.widgetDatabases)
self.btnDbRefresh.setObjectName("btnDbRefresh")
self.horizontalLayout.addWidget(self.btnDbRefresh)
self.verticalLayout_3.addLayout(self.horizontalLayout)
self.gridLayout_5.addWidget(self.widgetDatabases, 2, 0, 1, 1)
self.line_4 = QtWidgets.QFrame(self.accountTab)
self.line_4.setFrameShape(QtWidgets.QFrame.HLine)
self.line_4.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line_4.setObjectName("line_4")
self.gridLayout_5.addWidget(self.line_4, 3, 0, 1, 1)
self.tabWidget.addTab(self.accountTab, "")
self.aboutTab = QtWidgets.QWidget()
self.aboutTab.setObjectName("aboutTab")
self.verticalLayout = QtWidgets.QVBoxLayout(self.aboutTab)
self.verticalLayout.setObjectName("verticalLayout")
self.logo = QtWidgets.QLabel(self.aboutTab)
self.logo.setAutoFillBackground(False)
self.logo.setPixmap(QtGui.QPixmap(":/plugins/qgiscloud/logo.png"))
self.logo.setScaledContents(False)
self.logo.setAlignment(QtCore.Qt.AlignCenter)
self.logo.setObjectName("logo")
self.verticalLayout.addWidget(self.logo)
self.horizontalLayout_8 = QtWidgets.QHBoxLayout()
self.horizontalLayout_8.setObjectName("horizontalLayout_8")
self.label_6 = QtWidgets.QLabel(self.aboutTab)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.label_6.sizePolicy().hasHeightForWidth())
self.label_6.setSizePolicy(sizePolicy)
self.label_6.setObjectName("label_6")
self.horizontalLayout_8.addWidget(self.label_6)
self.lblVersionPlugin = QtWidgets.QLabel(self.aboutTab)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.lblVersionPlugin.sizePolicy().hasHeightForWidth())
self.lblVersionPlugin.setSizePolicy(sizePolicy)
self.lblVersionPlugin.setText("")
self.lblVersionPlugin.setObjectName("lblVersionPlugin")
self.horizontalLayout_8.addWidget(self.lblVersionPlugin)
self.verticalLayout.addLayout(self.horizontalLayout_8)
self.aboutText = QtWidgets.QTextEdit(self.aboutTab)
self.aboutText.setObjectName("aboutText")
self.verticalLayout.addWidget(self.aboutText)
self.tabWidget.addTab(self.aboutTab, "")
self.gridLayout_3.addWidget(self.tabWidget, 1, 0, 1, 1)
QgisCloudPlugin.setWidget(self.dockWidgetContents)
self.label_2.setBuddy(self.editServer)
self.retranslateUi(QgisCloudPlugin)
self.tabWidget.setCurrentIndex(2)
QtCore.QMetaObject.connectSlotsByName(QgisCloudPlugin)
class ElementTableGUI(QWidget):
"""Create the periodic element gui with toggleble buttons
for element selection and preview signal triggered with
mouse hover events and right click for optional menu/ window.
Initialisation can take python list with elements
for which buttons is pre-toggled:
-----------
args:
prechecked -- python list with elements (abbrevations), the
buttons which should be initially pushed.
state_list = python list -- list of elements (abbrevations) for buttons
which should be disabled (by default) or enabled (if state_list_enables
is True.
state_list_enables = False (default) -- set interpretation of state_list
silent_disabled = False (default) -- controls the behaviour of disabled
element buttons if True, then disabled buttons do not emit any signal
disable_fancy = False (default) -- controls if do button geometry changes
with hover over/off events
buttons_auto_depress = False (Default) -- controls if element buttons hold
its state or only triggers when pushed (and automatically depresses).
-----------
additionally to native QtGui.QWidget provides
such signals:
elementConsidered -- signal which emits element abbrevation
when mouse hovers over the button, or the coresponding
button gets focus, or is emitted by text input interface.
elementUnconsidered -- emits element abrevation at moment mouse
leaves the button area
elementChecked -- emits the element abbrevation when button
changes to checked possition.
elementUnchecked -- emits the element abbrevation when button
changes to unchecked possition.
elementRightClicked -- emits the element abbrevation when
button gets right clicked.
elementTriggered -- emits the element abbrevation when button gets
triggered (intended to be used with buttons_auto_depress=True)
allElementsCleared -- emits, when the clear all button clicked.
Alternatively the element by element could be dissabled,
however this signal can be much faster.
"""
# preview slots:
elementConsidered = QtCore.pyqtSignal(str)
elementUnconsidered = QtCore.pyqtSignal(str)
# button press slots:
elementChecked = QtCore.pyqtSignal(str)
elementUnchecked = QtCore.pyqtSignal(str)
elementTriggered = QtCore.pyqtSignal(str)
# right_mouse_button_press_slot:
elementRightClicked = QtCore.pyqtSignal(str)
allElementsCleared = QtCore.pyqtSignal()
def __init__(self,
parent=None,
prechecked=[],
state_list=[],
state_list_enables=False,
silent_disabled=False,
disable_fancy=False,
buttons_auto_depress=False):
super().__init__()
if type(state_list) == str:
state_list = parse_elements(state_list)
if (len(prechecked) > 0) and buttons_auto_depress:
warnings.warn(
"element table is initialised with opposite"
" arguements - seting buttons to auto depress rules out"
" using prechecked element list. The list is ignored")
prechecked = []
self.setWindowTitle('Element Table')
layout = QGridLayout(self)
self.setLayout(layout)
layout.setSpacing(0)
layout.setContentsMargins(4, 4, 4, 4)
partly_disabled = not silent_disabled
self._setup_table(prechecked, state_list, state_list_enables,
partly_disabled, disable_fancy, buttons_auto_depress)
self._setup_text_interface()
self._setup_clear_all()
if not buttons_auto_depress:
self.set_table_mode('multi') # default
else:
self.set_table_mode('single')
self.resize(400, 250)
def _setup_clear_all(self):
self.clear_all_button = QPushButton('Clear all')
self.layout().addWidget(self.clear_all_button, 7, 0, 2, 3)
self.clear_all_button.pressed.connect(self.clear_all)
self.clear_all_button.setMinimumSize(32, 32)
self.clear_all_button.setMaximumSize(512, 512)
def _setup_text_interface(self):
self.textInterface = QLineEdit()
self.textInterface.setMinimumSize(16, 16)
self.layout().addWidget(self.textInterface, 8, 9, 1, 9)
self.textInterface.returnPressed.connect(self.toggle_elements)
self.textInterface.textChanged.connect(self.consider_element)
self.textInterface.setMaximumSize(512, 1024)
def set_extended_completer(self):
completer = QCompleter(
list(pt_indexes.keys()) + list(geo_groups.keys()) +
list(names_abbrv.keys()))
self.textInterface.setCompleter(completer)
def set_simple_completer(self):
completer = QCompleter(list(pt_indexes.keys()))
self.textInterface.setCompleter(completer)
def set_table_mode(self, mode):
if mode == 'multi':
self.textInterface.setEnabled(True)
self.set_extended_completer()
self.textInterface.setToolTip(
"text interface.\n"
"Input abbrevations of elements:\n"
" without any space:\n"
" AlSiNaK\n"
" with any separators like comma/space:\n"
" Al;Br K,La\n"
"abbrevations of element groups (in all caps):\n"
" HFSE, REE, REE_SEM, LILE, MAJOR\n"
"Use '-' (minus) sign to disable elements:\n"
" -AlCa, K; P -> toggles off Al, Ca, K, P\n"
"HFSE - Nb -> toggles on HFSE elements, but switches off Nb")
self.clear_all_button.setEnabled(True)
self.textInterface.setInputMask("")
elif mode == 'single':
self.textInterface.setEnabled(False)
# self.set_simple_completer()
# self.textInterface.setToolTip(
# "Enter a single element abbreviation")
self.clear_all_button.setEnabled(False)
# self.textInterface.setInputMask(">A<a")
for i in geo_groups['ALL']:
self.getButton_by_name(i).change_mode(mode)
def getButton(self, index):
"""helper function to get button by position
index - tuple (row, column)"""
item = self.layout().itemAtPosition(*index)
return item.widget()
def getButton_by_name(self, name):
"""helper function to get button by abbrevation of
the element"""
item = self.layout().itemAtPosition(*pt_indexes[name])
return item.widget()
def toggle_elements(self):
ptext = self.textInterface.text()
positive_text, negative_text = separate_text(ptext)
# clear text interface:
self.textInterface.clear()
# parse what to add first:
positive_list = parse_elements(positive_text)
self.toggle_on(positive_list)
# parse what to remove:
negative_list = parse_elements(negative_text)
self.toggle_off(negative_list)
def consider_element(self, text):
positive_text = separate_text(text)[0]
positive_list = parse_elements(positive_text)
self.elementUnconsidered.emit('')
for i in positive_list:
self.elementConsidered.emit(i)
def toggle_on(self, toggle_list):
for i in toggle_list:
button = self.getButton(pt_indexes[i])
if button.isEnabled():
button.setChecked(True)
def toggle_off(self, toggle_list):
for i in toggle_list:
button = self.getButton(pt_indexes[i])
if button.isEnabled():
button.setChecked(False)
def clear_all(self):
"""uncheck all buttons, and send single signal instead of
many per button, which allows to do related action in
more snappy maner."""
self.blockSignals(True)
self.toggle_off(geo_groups['ALL'])
self.blockSignals(False)
self.allElementsCleared.emit()
def _setup_table(self, prechecked_elements, state_list, state_list_enables,
partly_disabled, disable_fancy, auto_depresso):
self.signalMapper = QtCore.QSignalMapper(self)
self.signalMapper.mapped[QWidget].connect(self.previewToggler)
self.signalMapper2 = QtCore.QSignalMapper(self)
self.signalMapper2.mapped[QWidget].connect(self.elementToggler)
self.signalMapper3 = QtCore.QSignalMapper(self)
self.signalMapper3.mapped[QWidget].connect(self.emit_right_clicked)
self.signalMapper4 = QtCore.QSignalMapper(self)
self.signalMapper4.mapped[QWidget].connect(self.focus_on_toggler)
self.signalMapper5 = QtCore.QSignalMapper(self)
self.signalMapper5.mapped[QWidget].connect(self.focus_off_toggler)
self.signalMapper6 = QtCore.QSignalMapper(self)
self.signalMapper6.mapped[QWidget].connect(self.emit_triggered)
is_checkable = not auto_depresso
for i in pt_indexes:
pt_button = HoverableButton(i,
partly_disabled=partly_disabled,
disable_fancy=disable_fancy,
is_checkable=is_checkable)
pt_button.setMinimumSize(16, 16)
pt_button.setMaximumSize(512, 512)
if i in prechecked_elements:
pt_button.setChecked(True)
self.layout().addWidget(pt_button, pt_indexes[i][0],
pt_indexes[i][1])
# pt_button.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
pt_button.hoverChanged.connect(self.signalMapper.map)
pt_button.toggled.connect(self.signalMapper2.map)
pt_button.rightClicked.connect(self.signalMapper3.map)
pt_button.gainedFocus.connect(self.signalMapper4.map)
pt_button.lostFocus.connect(self.signalMapper5.map)
pt_button.pressed.connect(self.signalMapper6.map)
self.signalMapper.setMapping(pt_button, pt_button)
self.signalMapper2.setMapping(pt_button, pt_button)
self.signalMapper3.setMapping(pt_button, pt_button)
self.signalMapper4.setMapping(pt_button, pt_button)
self.signalMapper5.setMapping(pt_button, pt_button)
self.signalMapper6.setMapping(pt_button, pt_button)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
line.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.layout().addWidget(line, 6, 3, 1, 15)
# dissable elements/buttons for provided list:
if state_list_enables:
disabled_elements = set(pt_indexes).difference(state_list)
else:
disabled_elements = state_list
for i in disabled_elements:
self.getButton(pt_indexes[i]).setEnabled(False)
lant_text = QLabel('Lan')
act_text = QLabel('Act')
lant_text.setAlignment(QtCore.Qt.AlignCenter)
act_text.setAlignment(QtCore.Qt.AlignCenter)
self.layout().addWidget(lant_text, 5, 2)
self.layout().addWidget(act_text, 6, 2)
lant_text.setEnabled(False)
act_text.setEnabled(False)
def update_state(self, element, enable=True):
"""update state of button for given element
(enable, disable); this method is intended to
be used when model containing element list is
updated (new element added or removed)"""
self.signalMapper2.blockSignals(True)
button = self.getButton_by_name(element)
if not enable and button.isChecked():
button.setChecked(False)
button.setEnabled(enable)
self.signalMapper2.blockSignals(False)
def keyPressEvent(self, event):
"""Jump to text interface at shift key press"""
if event.key() == QtCore.Qt.Key_Shift:
self.textInterface.setFocus()
# @QtCore.pyqtSlot(QtCore.QObject) # NOTE decorators are commented out
# as pyQt5.7 made regression with using QObject or QWidget in signals
# or is it the problem with mapping of signals?
def previewToggler(self, button):
# if button.isEnabled():
if button.hover_state:
self.elementConsidered.emit(button.text())
else:
self.elementUnconsidered.emit(button.text())
def focus_on_toggler(self, button):
"""this is for sending same signal as with hovering, but by
"Tab" jumping through buttons"""
self.elementConsidered.emit(button.text())
def focus_off_toggler(self, button):
"""this is for sending same signal as with hovering, but by
"Tab" jumping through buttons"""
self.elementUnconsidered.emit(button.text())
# @QtCore.pyqtSlot(QtCore.QObject)
def elementToggler(self, button):
if button.isChecked():
self.elementChecked.emit(button.text())
if button.hover_state and button.fancy:
button.setGeometry(button.orig_size)
else:
self.elementUnchecked.emit(button.text())
# @QtCore.pyqtSlot(QtCore.QObject)
def emit_right_clicked(self, button):
self.elementRightClicked.emit(button.text())
def emit_triggered(self, button):
self.elementTriggered.emit(button.text())
def switch_button_wo_trigger(self, elements, press=True):
"""This method is intended to be connected with list model signal;
it blocks signal so that there would be no loop of triggering
back and forth between button and list model if state of checkbox
in list is bined with state of button."""
self.signalMapper2.blockSignals(True)
if press:
self.toggle_on(elements)
else:
self.toggle_off(elements)
self.signalMapper2.blockSignals(False)
class HoverableButton(QToolButton):
"""A Customised QToolButton, which emit
additional signals when hovered over/off, right clicked
or focuse changed with Tabulator
----------------
initialisation arguments:
name -- text which will be shown on button
partly_disabled = True (default) -- controls behaviour,
when set to True, the button when disabled, still
emit custom signals and if fancy is enabled, react to
mouse over events.
disable_fancy = False --if set to True, then does not do
the graphic geometric changes when hovered over/off.
is_checkable = True (default) -- controls if button stays
pushed when clicked, utill depressed by next click.
"""
hoverChanged = QtCore.pyqtSignal()
gainedFocus = QtCore.pyqtSignal()
lostFocus = QtCore.pyqtSignal()
rightClicked = QtCore.pyqtSignal()
def __init__(self,
name,
partly_disabled=True,
disable_fancy=False,
is_checkable=True):
QAbstractButton.__init__(self)
self.partly_disabled = partly_disabled
self.fancy = not disable_fancy
self.setMouseTracking(1)
self.setText(name)
if is_checkable:
self.setCheckable(True)
if not self.fancy:
self.setAutoRaise(True)
self.hover_state = False
self.orig_size = self.geometry()
self.installEventFilter(self)
def change_mode(self, mode):
if mode == "single":
self.setCheckable(False)
elif mode == "multi":
self.setCheckable(True)
def focusInEvent(self, event):
self.gainedFocus.emit()
super().focusInEvent(event)
def focusOutEvent(self, event):
self.lostFocus.emit()
super().focusOutEvent(event)
def enterEvent(self, event):
# signaling
if self.isEnabled() or self.partly_disabled:
self.hover_state = True
self.hoverChanged.emit()
# graphics
if self.fancy and (self.isEnabled() or self.partly_disabled):
self.orig_size = self.geometry()
# some fancy graphic effects (inspired by KDE kalzium):
self.setGeometry(self.orig_size.x() - self.orig_size.width() / 5,
self.orig_size.y() - self.orig_size.height() / 5,
self.orig_size.width() * 1.4,
self.orig_size.height() * 1.4)
self.raise_()
def leaveEvent(self, event):
if self.isEnabled() or self.partly_disabled:
self.hover_state = False
self.hoverChanged.emit()
if self.fancy and (self.isEnabled() or self.partly_disabled):
self.setGeometry(self.orig_size)
def eventFilter(self, QObject, event):
if event.type() == QtCore.QEvent.MouseButtonPress:
if event.button() == QtCore.Qt.RightButton:
self.rightClicked.emit()
return False
def createMapTips(self):
""" Create MapTips on the map """
self.timer_map_tips = QtCore.QTimer(self.canvas)
self.map_tip = QgsMapTip()
self.canvas.xyCoordinates.connect(self.mapTipXYChanged)
self.timer_map_tips.timeout.connect(self.showMapTip)
import requests
import site
from qgis.PyQt import QtCore
from qgis.core import QgsMessageLog
from qgis.utils import iface
# Ensure that the ext-libs for the plugin are near the front of the path
# (important on Linux)
dirpath = os.path.abspath(os.path.join(os.path.dirname(__file__), 'ext-libs'))
sys.path, remainder = sys.path[:1], sys.path[1:]
site.addsitedir(dirpath)
sys.path.extend(remainder)
debug = QtCore.QSettings().value('LDMP/debug', True)
def log(message, level=0):
if debug:
QgsMessageLog.logMessage(message, tag="trends.earth", level=level)
# noinspection PyPep8Naming
def classFactory(iface): # pylint: disable=invalid-name
"""Load LDMPPlugin class from file LDMP.
:param iface: A QGIS interface instance.
:type iface: QgsInterface
def _test_operations(self, md, conn):
"""Common tests"""
capabilities = conn.capabilities()
# Schema operations
if (capabilities & QgsAbstractDatabaseProviderConnection.CreateSchema
and
capabilities & QgsAbstractDatabaseProviderConnection.Schemas
and capabilities
& QgsAbstractDatabaseProviderConnection.DropSchema):
# Start clean
if 'myNewSchema' in conn.schemas():
conn.dropSchema('myNewSchema', True)
# Create
conn.createSchema('myNewSchema')
schemas = conn.schemas()
self.assertTrue('myNewSchema' in schemas)
# Create again
with self.assertRaises(QgsProviderConnectionException) as ex:
conn.createSchema('myNewSchema')
# Test rename
if capabilities & QgsAbstractDatabaseProviderConnection.RenameSchema:
# Rename
conn.renameSchema('myNewSchema', 'myVeryNewSchema')
schemas = conn.schemas()
self.assertTrue('myVeryNewSchema' in schemas)
self.assertFalse('myNewSchema' in schemas)
conn.renameSchema('myVeryNewSchema', 'myNewSchema')
schemas = conn.schemas()
self.assertFalse('myVeryNewSchema' in schemas)
self.assertTrue('myNewSchema' in schemas)
# Drop
conn.dropSchema('myNewSchema')
schemas = conn.schemas()
self.assertFalse('myNewSchema' in schemas)
# UTF8 schema
conn.createSchema('myUtf8\U0001f604NewSchema')
schemas = conn.schemas()
conn.dropSchema('myUtf8\U0001f604NewSchema')
schemas = conn.schemas()
self.assertFalse('myUtf8\U0001f604NewSchema' in schemas)
# Table operations
if (capabilities
& QgsAbstractDatabaseProviderConnection.CreateVectorTable
and capabilities & QgsAbstractDatabaseProviderConnection.Tables
and capabilities
& QgsAbstractDatabaseProviderConnection.DropVectorTable):
if capabilities & QgsAbstractDatabaseProviderConnection.CreateSchema:
schema = 'myNewSchema'
conn.createSchema('myNewSchema')
else:
schema = 'public'
# Start clean
if 'myNewTable' in self._table_names(conn.tables(schema)):
conn.dropVectorTable(schema, 'myNewTable')
fields = QgsFields()
fields.append(QgsField("string_t", QVariant.String))
fields.append(QgsField("long_t", QVariant.LongLong))
fields.append(QgsField("double_t", QVariant.Double))
fields.append(QgsField("integer_t", QVariant.Int))
fields.append(QgsField("date_t", QVariant.Date))
fields.append(QgsField("datetime_t", QVariant.DateTime))
fields.append(QgsField("time_t", QVariant.Time))
options = {}
crs = QgsCoordinateReferenceSystem.fromEpsgId(3857)
typ = QgsWkbTypes.LineString
# Create
conn.createVectorTable(schema, 'myNewTable', fields, typ, crs,
True, options)
table_names = self._table_names(conn.tables(schema))
self.assertTrue('myNewTable' in table_names)
# Create UTF8 table
conn.createVectorTable(schema, 'myUtf8\U0001f604Table', fields,
typ, crs, True, options)
table_names = self._table_names(conn.tables(schema))
self.assertTrue('myNewTable' in table_names)
self.assertTrue('myUtf8\U0001f604Table' in table_names)
conn.dropVectorTable(schema, 'myUtf8\U0001f604Table')
table_names = self._table_names(conn.tables(schema))
self.assertFalse('myUtf8\U0001f604Table' in table_names)
self.assertTrue('myNewTable' in table_names)
# insert something, because otherwise MSSQL cannot guess
if self.providerKey in ['hana', 'mssql']:
f = QgsFeature(fields)
f.setGeometry(
QgsGeometry.fromWkt('LineString (-72.345 71.987, -80 80)'))
vl = QgsVectorLayer(conn.tableUri('myNewSchema', 'myNewTable'),
'vl', self.providerKey)
vl.dataProvider().addFeatures([f])
# Check table information
table_properties = conn.tables(schema)
table_property = self._table_by_name(table_properties,
'myNewTable')
self.assertEqual(table_property.maxCoordinateDimensions(), 2)
self.assertIsNotNone(table_property)
self.assertEqual(table_property.tableName(), 'myNewTable')
self.assertEqual(table_property.geometryColumnCount(), 1)
self.assertEqual(table_property.geometryColumnTypes()[0].wkbType,
QgsWkbTypes.LineString)
cols = table_property.geometryColumnTypes()
self.assertEqual(cols[0].crs,
QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(table_property.defaultName(), 'myNewTable')
# Check aspatial tables
conn.createVectorTable(schema, 'myNewAspatialTable', fields,
QgsWkbTypes.NoGeometry, crs, True, options)
table_properties = conn.tables(
schema, QgsAbstractDatabaseProviderConnection.Aspatial)
table_property = self._table_by_name(table_properties,
'myNewAspatialTable')
self.assertIsNotNone(table_property)
self.assertEqual(table_property.maxCoordinateDimensions(), 0)
self.assertEqual(table_property.tableName(), 'myNewAspatialTable')
self.assertEqual(table_property.geometryColumnCount(), 0)
self.assertEqual(table_property.geometryColumn(), '')
self.assertEqual(table_property.defaultName(),
'myNewAspatialTable')
cols = table_property.geometryColumnTypes()
# We always return geom col types, even when there is no geometry
self.assertEqual(cols[0].wkbType, QgsWkbTypes.NoGeometry)
self.assertFalse(cols[0].crs.isValid())
self.assertFalse(table_property.flags()
& QgsAbstractDatabaseProviderConnection.Raster)
self.assertFalse(table_property.flags()
& QgsAbstractDatabaseProviderConnection.Vector)
self.assertTrue(table_property.flags()
& QgsAbstractDatabaseProviderConnection.Aspatial)
# Check executeSql
has_schema = capabilities & QgsAbstractDatabaseProviderConnection.Schemas
if capabilities & QgsAbstractDatabaseProviderConnection.ExecuteSql:
if has_schema:
table = "\"%s\".\"myNewAspatialTable\"" % schema
else:
table = 'myNewAspatialTable'
# MSSQL literal syntax for UTF8 requires 'N' prefix
sql = "INSERT INTO %s (\"string_t\", \"long_t\", \"double_t\", \"integer_t\", \"date_t\", \"datetime_t\", \"time_t\") VALUES (%s'QGIS Rocks - \U0001f604', 666, 1.234, 1234, '2019-07-08', '2019-07-08T12:00:12', '12:00:13.00')" % (
table, 'N' if self.providerKey == 'mssql' else '')
res = conn.executeSql(sql)
self.assertEqual(res, [])
sql = "SELECT \"string_t\", \"long_t\", \"double_t\", \"integer_t\", \"date_t\", \"datetime_t\" FROM %s" % table
res = conn.executeSql(sql)
# GPKG and spatialite have no type for time
self.assertEqual(res, [[
'QGIS Rocks - \U0001f604', 666, 1.234, 1234,
QtCore.QDate(2019, 7, 8)
if not self.treat_date_as_string() else '2019-07-08',
QtCore.QDateTime(2019, 7, 8, 12, 0, 12)
]])
# Test column names
res = conn.execSql(sql)
rows = res.rows()
self.assertEqual(rows, [[
'QGIS Rocks - \U0001f604', 666, 1.234, 1234,
QtCore.QDate(2019, 7, 8)
if not self.treat_date_as_string() else '2019-07-08',
QtCore.QDateTime(2019, 7, 8, 12, 0, 12)
]])
self.assertEqual(res.columns(), [
'string_t', 'long_t', 'double_t', 'integer_t', 'date_t',
'datetime_t'
])
# Test iterator
old_rows = rows
res = conn.execSql(sql)
rows = []
self.assertTrue(res.hasNextRow())
for row in res:
rows.append(row)
self.assertEqual(rows, old_rows)
# Java style
res = conn.execSql(sql)
rows = []
self.assertTrue(res.hasNextRow())
while res.hasNextRow():
rows.append(res.nextRow())
self.assertFalse(res.hasNextRow())
# Test time_t
sql = "SELECT \"time_t\" FROM %s" % table
res = conn.executeSql(sql)
# This does not work in MSSQL and returns a QByteArray, we have no way to know that it is a time
# value and there is no way we can convert it.
if self.providerKey != 'mssql':
self.assertIn(
res, ([[QtCore.QTime(12, 0, 13)]], [['12:00:13.00']]))
sql = "DELETE FROM %s WHERE \"string_t\" = %s'QGIS Rocks - \U0001f604'" % (
table, 'N' if self.providerKey == 'mssql' else '')
res = conn.executeSql(sql)
self.assertEqual(res, [])
sql = "SELECT \"string_t\", \"integer_t\" FROM %s" % table
res = conn.executeSql(sql)
self.assertEqual(res, [])
# Check that we do NOT get the aspatial table when querying for vectors
table_names = self._table_names(
conn.tables(schema,
QgsAbstractDatabaseProviderConnection.Vector))
self.assertTrue('myNewTable' in table_names)
self.assertFalse('myNewAspatialTable' in table_names)
# Query for rasters (in qgis_test schema or no schema for GPKG, spatialite has no support)
if self.providerKey not in ('spatialite', 'mssql', 'hana'):
table_properties = conn.tables(
'qgis_test', QgsAbstractDatabaseProviderConnection.Raster)
# At least one raster should be there (except for spatialite)
self.assertTrue(len(table_properties) >= 1)
table_property = table_properties[0]
self.assertTrue(table_property.flags()
& QgsAbstractDatabaseProviderConnection.Raster)
self.assertFalse(
table_property.flags()
& QgsAbstractDatabaseProviderConnection.Vector)
self.assertFalse(
table_property.flags()
& QgsAbstractDatabaseProviderConnection.Aspatial)
if capabilities & QgsAbstractDatabaseProviderConnection.RenameVectorTable:
# Rename
conn.renameVectorTable(schema, 'myNewTable', 'myVeryNewTable')
tables = self._table_names(conn.tables(schema))
self.assertFalse('myNewTable' in tables)
self.assertTrue('myVeryNewTable' in tables)
# Rename it back
conn.renameVectorTable(schema, 'myVeryNewTable', 'myNewTable')
tables = self._table_names(conn.tables(schema))
self.assertTrue('myNewTable' in tables)
self.assertFalse('myVeryNewTable' in tables)
# Vacuum
if capabilities & QgsAbstractDatabaseProviderConnection.Vacuum:
conn.vacuum('myNewSchema', 'myNewTable')
# Spatial index
spatial_index_exists = False
# we don't initially know if a spatial index exists -- some formats may create them by default, others not
if capabilities & QgsAbstractDatabaseProviderConnection.SpatialIndexExists:
spatial_index_exists = conn.spatialIndexExists(
'myNewSchema', 'myNewTable', 'geom')
if capabilities & QgsAbstractDatabaseProviderConnection.DeleteSpatialIndex:
if spatial_index_exists:
conn.deleteSpatialIndex('myNewSchema', 'myNewTable',
'geom')
if capabilities & QgsAbstractDatabaseProviderConnection.SpatialIndexExists:
self.assertFalse(
conn.spatialIndexExists('myNewSchema', 'myNewTable',
'geom'))
if capabilities & (
QgsAbstractDatabaseProviderConnection.CreateSpatialIndex |
QgsAbstractDatabaseProviderConnection.SpatialIndexExists):
options = QgsAbstractDatabaseProviderConnection.SpatialIndexOptions(
)
options.geometryColumnName = 'geom'
if not conn.spatialIndexExists('myNewSchema', 'myNewTable',
options.geometryColumnName):
conn.createSpatialIndex('myNewSchema', 'myNewTable',
options)
self.assertTrue(
conn.spatialIndexExists('myNewSchema', 'myNewTable',
'geom'))
# now we know for certain a spatial index exists, let's retry dropping it
if capabilities & QgsAbstractDatabaseProviderConnection.DeleteSpatialIndex:
conn.deleteSpatialIndex('myNewSchema', 'myNewTable',
'geom')
if capabilities & QgsAbstractDatabaseProviderConnection.SpatialIndexExists:
self.assertFalse(
conn.spatialIndexExists('myNewSchema',
'myNewTable', 'geom'))
if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema:
# Drop schema (should fail)
with self.assertRaises(QgsProviderConnectionException) as ex:
conn.dropSchema('myNewSchema')
# Check some column types operations
table = self._table_by_name(conn.tables(schema), 'myNewTable')
self.assertEqual(len(table.geometryColumnTypes()), 1)
ct = table.geometryColumnTypes()[0]
self.assertEqual(ct.crs,
QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(ct.wkbType, QgsWkbTypes.LineString)
# Add a new (existing type)
table.addGeometryColumnType(
QgsWkbTypes.LineString,
QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(len(table.geometryColumnTypes()), 1)
ct = table.geometryColumnTypes()[0]
self.assertEqual(ct.crs,
QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(ct.wkbType, QgsWkbTypes.LineString)
# Add a new one
table.addGeometryColumnType(
QgsWkbTypes.LineString,
QgsCoordinateReferenceSystem.fromEpsgId(4326))
self.assertEqual(len(table.geometryColumnTypes()), 2)
ct = table.geometryColumnTypes()[0]
self.assertEqual(ct.crs,
QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(ct.wkbType, QgsWkbTypes.LineString)
ct = table.geometryColumnTypes()[1]
self.assertEqual(ct.crs,
QgsCoordinateReferenceSystem.fromEpsgId(4326))
self.assertEqual(ct.wkbType, QgsWkbTypes.LineString)
# Check fields
fields = conn.fields('myNewSchema', 'myNewTable')
for f in [
'string_t', 'long_t', 'double_t', 'integer_t', 'date_t',
'datetime_t', 'time_t'
]:
self.assertTrue(f in fields.names())
if capabilities & QgsAbstractDatabaseProviderConnection.AddField:
field = QgsField('short_lived_field', QVariant.Int, 'integer')
conn.addField(field, 'myNewSchema', 'myNewTable')
fields = conn.fields('myNewSchema', 'myNewTable')
self.assertTrue('short_lived_field' in fields.names())
if capabilities & QgsAbstractDatabaseProviderConnection.DeleteField:
conn.deleteField('short_lived_field', 'myNewSchema',
'myNewTable')
# This fails on Travis for spatialite, for no particular reason
if self.providerKey == 'spatialite' and not os.environ.get(
'TRAVIS', False):
fields = conn.fields('myNewSchema', 'myNewTable')
self.assertFalse('short_lived_field' in fields.names())
# Drop table
conn.dropVectorTable(schema, 'myNewTable')
conn.dropVectorTable(schema, 'myNewAspatialTable')
table_names = self._table_names(conn.tables(schema))
self.assertFalse('myNewTable' in table_names)
if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema:
# Drop schema
conn.dropSchema('myNewSchema')
self.assertFalse('myNewSchema' in conn.schemas())
conns = md.connections()
self.assertTrue(
isinstance(
list(conns.values())[0],
QgsAbstractDatabaseProviderConnection))
# Remove connection
spy_deleted = QSignalSpy(md.connectionDeleted)
md.deleteConnection('qgis_test1')
self.assertEqual(list(md.connections().values()), [])
self.assertEqual(len(spy_deleted), 1)
def _test_operations(self, md, conn):
"""Common tests"""
capabilities = conn.capabilities()
# Schema operations
if (capabilities & QgsAbstractDatabaseProviderConnection.CreateSchema and
capabilities & QgsAbstractDatabaseProviderConnection.Schemas and
capabilities & QgsAbstractDatabaseProviderConnection.RenameSchema and
capabilities & QgsAbstractDatabaseProviderConnection.DropSchema):
if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema and 'myNewSchema' in conn.schemas():
conn.dropSchema('myNewSchema', True)
# Create
conn.createSchema('myNewSchema')
schemas = conn.schemas()
self.assertTrue('myNewSchema' in schemas)
# Create again
with self.assertRaises(QgsProviderConnectionException) as ex:
conn.createSchema('myNewSchema')
# Rename
conn.renameSchema('myNewSchema', 'myVeryNewSchema')
schemas = conn.schemas()
self.assertTrue('myVeryNewSchema' in schemas)
self.assertFalse('myNewSchema' in schemas)
# Drop
conn.dropSchema('myVeryNewSchema')
schemas = conn.schemas()
self.assertFalse('myVeryNewSchema' in schemas)
# Table operations
if (capabilities & QgsAbstractDatabaseProviderConnection.CreateVectorTable and
capabilities & QgsAbstractDatabaseProviderConnection.Tables and
capabilities & QgsAbstractDatabaseProviderConnection.RenameVectorTable and
capabilities & QgsAbstractDatabaseProviderConnection.DropVectorTable):
if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema and 'myNewSchema' in conn.schemas():
conn.dropSchema('myNewSchema', True)
if capabilities & QgsAbstractDatabaseProviderConnection.CreateSchema:
schema = 'myNewSchema'
conn.createSchema('myNewSchema')
else:
schema = 'public'
if 'myNewTable' in self._table_names(conn.tables(schema)):
conn.dropVectorTable(schema, 'myNewTable')
fields = QgsFields()
fields.append(QgsField("string", QVariant.String))
fields.append(QgsField("long", QVariant.LongLong))
fields.append(QgsField("double", QVariant.Double))
fields.append(QgsField("integer", QVariant.Int))
fields.append(QgsField("date", QVariant.Date))
fields.append(QgsField("datetime", QVariant.DateTime))
fields.append(QgsField("time", QVariant.Time))
options = {}
crs = QgsCoordinateReferenceSystem.fromEpsgId(3857)
typ = QgsWkbTypes.LineString
# Create
conn.createVectorTable(schema, 'myNewTable', fields, typ, crs, True, options)
table_names = self._table_names(conn.tables(schema))
self.assertTrue('myNewTable' in table_names)
# Check table information
table_properties = conn.tables(schema)
table_property = self._table_by_name(table_properties, 'myNewTable')
self.assertEqual(table_property.maxCoordinateDimensions(), 2)
self.assertIsNotNone(table_property)
self.assertEqual(table_property.tableName(), 'myNewTable')
self.assertEqual(table_property.geometryColumnCount(), 1)
self.assertEqual(table_property.geometryColumnTypes()[0].wkbType, QgsWkbTypes.LineString)
cols = table_property.geometryColumnTypes()
self.assertEqual(cols[0].crs, QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(table_property.defaultName(), 'myNewTable')
# Check aspatial tables
conn.createVectorTable(schema, 'myNewAspatialTable', fields, QgsWkbTypes.NoGeometry, crs, True, options)
table_properties = conn.tables(schema, QgsAbstractDatabaseProviderConnection.Aspatial)
table_property = self._table_by_name(table_properties, 'myNewAspatialTable')
self.assertIsNotNone(table_property)
self.assertEqual(table_property.maxCoordinateDimensions(), 0)
self.assertEqual(table_property.tableName(), 'myNewAspatialTable')
self.assertEqual(table_property.geometryColumnCount(), 0)
self.assertEqual(table_property.geometryColumn(), '')
self.assertEqual(table_property.defaultName(), 'myNewAspatialTable')
cols = table_property.geometryColumnTypes()
self.assertEqual(cols[0].wkbType, QgsWkbTypes.NoGeometry)
self.assertFalse(cols[0].crs.isValid())
self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Raster)
self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Vector)
self.assertTrue(table_property.flags() & QgsAbstractDatabaseProviderConnection.Aspatial)
# Check executeSql
has_schema = capabilities & QgsAbstractDatabaseProviderConnection.Schemas
if capabilities & QgsAbstractDatabaseProviderConnection.ExecuteSql:
if has_schema:
table = "\"%s\".\"myNewAspatialTable\"" % schema
else:
table = 'myNewAspatialTable'
sql = "INSERT INTO %s (string, long, double, integer, date, datetime, time) VALUES ('QGIS Rocks - \U0001f604', 666, 1.234, 1234, '2019-07-08', '2019-07-08T12:00:12', '12:00:13.00')" % table
res = conn.executeSql(sql)
self.assertEqual(res, [])
sql = "SELECT string, long, double, integer, date, datetime FROM %s" % table
res = conn.executeSql(sql)
# GPKG has no type for time and spatialite has no support for dates and time ...
if self.providerKey == 'spatialite':
self.assertEqual(res, [['QGIS Rocks - \U0001f604', 666, 1.234, 1234, '2019-07-08', '2019-07-08T12:00:12']])
else:
self.assertEqual(res, [['QGIS Rocks - \U0001f604', 666, 1.234, 1234, QtCore.QDate(2019, 7, 8), QtCore.QDateTime(2019, 7, 8, 12, 0, 12)]])
sql = "SELECT time FROM %s" % table
res = conn.executeSql(sql)
self.assertIn(res, ([[QtCore.QTime(12, 0, 13)]], [['12:00:13.00']]))
sql = "DELETE FROM %s WHERE string = 'QGIS Rocks - \U0001f604'" % table
res = conn.executeSql(sql)
self.assertEqual(res, [])
sql = "SELECT string, integer FROM %s" % table
res = conn.executeSql(sql)
self.assertEqual(res, [])
# Check that we do NOT get the aspatial table when querying for vectors
table_names = self._table_names(conn.tables(schema, QgsAbstractDatabaseProviderConnection.Vector))
self.assertTrue('myNewTable' in table_names)
self.assertFalse('myNewAspatialTable' in table_names)
# Query for rasters (in qgis_test schema or no schema for GPKG, spatialite has no support)
if self.providerKey != 'spatialite':
table_properties = conn.tables('qgis_test', QgsAbstractDatabaseProviderConnection.Raster)
# At least one raster should be there (except for spatialite)
self.assertTrue(len(table_properties) >= 1)
table_property = table_properties[0]
self.assertTrue(table_property.flags() & QgsAbstractDatabaseProviderConnection.Raster)
self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Vector)
self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Aspatial)
# Rename
conn.renameVectorTable(schema, 'myNewTable', 'myVeryNewTable')
tables = self._table_names(conn.tables(schema))
self.assertFalse('myNewTable' in tables)
self.assertTrue('myVeryNewTable' in tables)
# Vacuum
if capabilities & QgsAbstractDatabaseProviderConnection.Vacuum:
conn.vacuum('myNewSchema', 'myVeryNewTable')
if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema:
# Drop schema (should fail)
with self.assertRaises(QgsProviderConnectionException) as ex:
conn.dropSchema('myNewSchema')
# Check some column types operations
table = self._table_by_name(conn.tables(schema), 'myVeryNewTable')
self.assertEqual(len(table.geometryColumnTypes()), 1)
ct = table.geometryColumnTypes()[0]
self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(ct.wkbType, QgsWkbTypes.LineString)
# Add a new (existing type)
table.addGeometryColumnType(QgsWkbTypes.LineString, QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(len(table.geometryColumnTypes()), 1)
ct = table.geometryColumnTypes()[0]
self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(ct.wkbType, QgsWkbTypes.LineString)
# Add a new one
table.addGeometryColumnType(QgsWkbTypes.LineString, QgsCoordinateReferenceSystem.fromEpsgId(4326))
self.assertEqual(len(table.geometryColumnTypes()), 2)
ct = table.geometryColumnTypes()[0]
self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857))
self.assertEqual(ct.wkbType, QgsWkbTypes.LineString)
ct = table.geometryColumnTypes()[1]
self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(4326))
self.assertEqual(ct.wkbType, QgsWkbTypes.LineString)
# Drop table
conn.dropVectorTable(schema, 'myVeryNewTable')
conn.dropVectorTable(schema, 'myNewAspatialTable')
table_names = self._table_names(conn.tables(schema))
self.assertFalse('myVeryNewTable' in table_names)
if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema:
# Drop schema
conn.dropSchema('myNewSchema')
self.assertFalse('myNewSchema' in conn.schemas())
conns = md.connections()
self.assertTrue(isinstance(list(conns.values())[0], QgsAbstractDatabaseProviderConnection))
# Remove connection
md.deleteConnection('qgis_test1')
self.assertEqual(list(md.connections().values()), [])
def _csmapToFile(self, dem, layer_set, outdir):
if dem.rasterUnitsPerPixelX() == dem.rasterUnitsPerPixelY():
dx = dem.rasterUnitsPerPixelX()
dy = dem.rasterUnitsPerPixelY()
w = dem.dataProvider().xSize()
h = dem.dataProvider().ySize()
elif dem.rasterUnitsPerPixelX() > dem.rasterUnitsPerPixelY():
dx = dem.rasterUnitsPerPixelY()
dy = dem.rasterUnitsPerPixelY()
w = int(dem.dataProvider().xSize() *
(dem.rasterUnitsPerPixelX() / dem.rasterUnitsPerPixelY()))
h = dem.dataProvider().ySize()
else:
dx = dem.rasterUnitsPerPixelX()
dy = dem.rasterUnitsPerPixelX()
w = dem.dataProvider().xSize()
h = int(dem.dataProvider().ySize() *
(dem.rasterUnitsPerPixelY() / dem.rasterUnitsPerPixelX()))
img = QtGui.QImage(QtCore.QSize(w, h),
QtGui.QImage.Format_ARGB32_Premultiplied)
color = QtGui.QColor(255, 255, 255)
img.fill(color.rgb())
setting = QgsMapSettings()
setting.setExtent(dem.dataProvider().extent())
setting.setDestinationCrs(dem.crs())
setting.setOutputSize(QtCore.QSize(w, h))
setting.setLayers(layer_set)
setting.updateDerived()
p = QtGui.QPainter()
p.begin(img)
render = QgsMapRendererCustomPainterJob(setting, p)
render.start()
render.waitForFinished()
p.end()
temp = tempfile.NamedTemporaryFile()
img.save(temp.name + ".tif", "tif")
src_ds = gdal.Open(temp.name + ".tif")
driver = gdal.GetDriverByName("GTiff")
filepath, filename = os.path.split(
str(dem.dataProvider().dataSourceUri()))
dst_file = outdir + r"/csmap_" + filename
dst_ds = driver.CreateCopy(dst_file, src_ds, 0)
geo_trans = [
dem.dataProvider().extent().xMinimum(), dx, 0,
dem.dataProvider().extent().yMaximum(), 0, dy * -1
]
dst_ds.SetGeoTransform(geo_trans)
dst_ds.SetProjection(str(dem.crs().toWkt()))
dst_ds = None
src_ds = None
temp.close()
self.result_files.append(dst_file)
def get_layer_styles_url_endpoint(self, layer_id: int):
return QtCore.QUrl(f"{self.api_url}/datasets/{layer_id}/styles/")
def get_qgis_app(requested_locale='en_US', qsetting=''):
""" Start one QGIS application to test against.
:param locale: The locale we want the qgis to launch with.
:type locale: str
:param qsetting: String to specify the QSettings. By default,
use empty string.
:type qsetting: str
:returns: Handle to QGIS app, canvas, iface and parent. If there are any
errors the tuple members will be returned as None.
:rtype: (QgsApplication, CANVAS, IFACE, PARENT)
If QGIS is already running the handle to that app will be returned.
"""
global QGIS_APP, PARENT, IFACE, CANVAS # pylint: disable=W0603
from qgis.PyQt.QtCore import QSettings
if qsetting:
settings = QSettings(qsetting)
else:
settings = QSettings()
default_user_directory = setting('defaultUserDirectory')
current_locale = general_setting('locale/userLocale',
default='en_US',
qsettings=settings)
locale_match = current_locale == requested_locale
if iface and locale_match:
from qgis.core import QgsApplication
QGIS_APP = QgsApplication
CANVAS = iface.mapCanvas()
PARENT = iface.mainWindow()
IFACE = iface
try:
from qgis.core import QgsApplication
from qgis.gui import QgsMapCanvas # pylint: disable=no-name-in-module
# noinspection PyPackageRequirements
from qgis.PyQt import QtWidgets, QtCore # pylint: disable=W0621
# noinspection PyPackageRequirements
from qgis.PyQt.QtCore import QCoreApplication, QSettings
from safe.test.qgis_interface import QgisInterface
except ImportError:
return None, None, None, None
if qsetting:
settings = QSettings(qsetting)
else:
settings = QSettings()
if not QGIS_APP:
gui_flag = True # All test will run qgis in gui mode
# AG: For testing purposes, we use our own configuration file
# instead of using the QGIS apps conf of the host
# noinspection PyCallByClass,PyArgumentList
QCoreApplication.setOrganizationName('QGIS')
# noinspection PyCallByClass,PyArgumentList
QCoreApplication.setOrganizationDomain('qgis.org')
# noinspection PyCallByClass,PyArgumentList
QCoreApplication.setApplicationName('QGIS2InaSAFETesting')
# We disabled message bars for now for extent selector as
# we don't have a main window to show them in TS - version 3.2
set_setting('show_extent_warnings', False, settings)
set_setting('showRubberBands', True, settings)
set_setting('show_extent_confirmations', False, settings)
set_setting('analysis_extents_mode', HAZARD_EXPOSURE, settings)
if default_user_directory:
set_setting('defaultUserDirectory', default_user_directory,
settings)
# noinspection PyPep8Naming
if 'argv' in dir(sys):
QGIS_APP = QgsApplication([p.encode('utf-8') for p in sys.argv],
gui_flag)
else:
QGIS_APP = QgsApplication([], gui_flag)
# Make sure QGIS_PREFIX_PATH is set in your env if needed!
QGIS_APP.initQgis()
# Initialize processing
processing.Processing.initialize()
s = QGIS_APP.showSettings()
LOGGER.debug(s)
if not locale_match:
"""Setup internationalisation for the plugin."""
# Save some settings
set_general_setting('locale/overrideFlag', True, settings)
set_general_setting('locale/userLocale', requested_locale, settings)
locale_name = str(requested_locale).split('_')[0]
# Also set the system locale to the user overridden local
# so that the inasafe library functions gettext will work
# .. see:: :py:func:`common.utilities`
os.environ['LANG'] = str(locale_name)
inasafe_translation_path = os.path.join(
safe_dir('i18n'), 'inasafe_' + str(locale_name) + '.qm')
if os.path.exists(inasafe_translation_path):
if isinstance(QGIS_APP, sip.wrappertype):
translator = QTranslator()
else:
translator = QTranslator(QGIS_APP)
result = translator.load(inasafe_translation_path)
if not result:
message = 'Failed to load translation for %s' % locale_name
raise Exception(message)
# noinspection PyTypeChecker,PyCallByClass
QCoreApplication.installTranslator(translator)
# at the end, reload InaSAFE modules so it will get translated too
reload_inasafe_modules()
if PARENT is None:
# noinspection PyPep8Naming
PARENT = QtWidgets.QWidget()
if CANVAS is None:
# noinspection PyPep8Naming
CANVAS = QgsMapCanvas(PARENT)
CANVAS.resize(QtCore.QSize(400, 400))
if IFACE is None:
# QgisInterface is a stub implementation of the QGIS plugin interface
# noinspection PyPep8Naming
IFACE = QgisInterface(CANVAS)
return QGIS_APP, CANVAS, IFACE, PARENT
def path(self):
return QtCore.QRegularExpression("/handlerone")
def testOgcApiHandler(self):
"""Test OGC API Handler"""
project = QgsProject()
project.read(unitTestDataPath('qgis_server') + '/test_project_api.qgs')
request = QgsBufferServerRequest(
'http://server.qgis.org/wfs3/collections/testlayer%20èé/items?limit=-1'
)
response = QgsBufferServerResponse()
ctx = QgsServerApiContext('/services/api1', request, response, project,
self.server.serverInterface())
h = Handler1()
self.assertTrue(
h.staticPath(ctx).endswith('/resources/server/api/ogc/static'))
self.assertEqual(h.path(), QtCore.QRegularExpression("/handlerone"))
self.assertEqual(h.description(), 'The first handler ever')
self.assertEqual(h.operationId(), 'handlerOne')
self.assertEqual(h.summary(), 'First of its name')
self.assertEqual(h.linkTitle(), 'Handler One Link Title')
self.assertEqual(h.linkType(), QgsServerOgcApi.data)
with self.assertRaises(QgsServerApiBadRequestException) as ex:
h.handleRequest(ctx)
self.assertEqual(str(ex.exception),
'Missing required argument: \'value1\'')
r = ctx.response()
self.assertEqual(r.data(), '')
with self.assertRaises(QgsServerApiBadRequestException) as ex:
h.values(ctx)
self.assertEqual(str(ex.exception),
'Missing required argument: \'value1\'')
# Add handler to API and test for /api2
ctx = QgsServerApiContext('/services/api2', request, response, project,
self.server.serverInterface())
api = QgsServerOgcApi(self.server.serverInterface(), '/api2', 'apitwo',
'a second api', '1.2')
api.registerHandler(h)
# Add a second handler (will be tested later)
h2 = Handler2()
api.registerHandler(h2)
ctx.request().setUrl(QtCore.QUrl('http://www.qgis.org/services/api1'))
with self.assertRaises(QgsServerApiBadRequestException) as ex:
api.executeRequest(ctx)
self.assertEqual(
str(ex.exception),
'Requested URI does not match any registered API handler')
ctx.request().setUrl(QtCore.QUrl('http://www.qgis.org/services/api2'))
with self.assertRaises(QgsServerApiBadRequestException) as ex:
api.executeRequest(ctx)
self.assertEqual(
str(ex.exception),
'Requested URI does not match any registered API handler')
ctx.request().setUrl(
QtCore.QUrl('http://www.qgis.org/services/api2/handlerone'))
with self.assertRaises(QgsServerApiBadRequestException) as ex:
api.executeRequest(ctx)
self.assertEqual(str(ex.exception),
'Missing required argument: \'value1\'')
ctx.request().setUrl(
QtCore.QUrl(
'http://www.qgis.org/services/api2/handlerone?value1=not+a+double'
))
with self.assertRaises(QgsServerApiBadRequestException) as ex:
api.executeRequest(ctx)
self.assertEqual(
str(ex.exception),
'Argument \'value1\' could not be converted to Double')
ctx.request().setUrl(
QtCore.QUrl(
'http://www.qgis.org/services/api2/handlerone?value1=1.2345'))
params = h.values(ctx)
self.assertEqual(params, {'value1': 1.2345})
api.executeRequest(ctx)
self.assertEqual(
json.loads(bytes(ctx.response().data()))['value1'], 1.2345)
# Test path fragments extraction
ctx.request().setUrl(
QtCore.QUrl(
'http://www.qgis.org/services/api2/handlertwo/00/555?value1=1.2345'
))
params = h2.values(ctx)
self.assertEqual(params, {
'code1': '00',
'value1': 1.2345,
'value2': None
})
# Test string encoding
ctx.request().setUrl(
QtCore.QUrl(
'http://www.qgis.org/services/api2/handlertwo/00/555?value1=1.2345&value2=a%2Fstring%20some'
))
params = h2.values(ctx)
self.assertEqual(params, {
'code1': '00',
'value1': 1.2345,
'value2': 'a/string some'
})
# Test links
self.assertEqual(
h2.href(ctx),
'http://www.qgis.org/services/api2/handlertwo/00/555?value1=1.2345&value2=a%2Fstring%20some'
)
self.assertEqual(
h2.href(ctx, '/extra'),
'http://www.qgis.org/services/api2/handlertwo/00/555/extra?value1=1.2345&value2=a%2Fstring%20some'
)
self.assertEqual(
h2.href(ctx, '/extra', 'json'),
'http://www.qgis.org/services/api2/handlertwo/00/555/extra.json?value1=1.2345&value2=a%2Fstring%20some'
)
# Test template path
self.assertTrue(
h2.templatePath(ctx).endswith(
'/resources/server/api/ogc/templates/services/api2/handlerTwo.html'
))
def path(self):
return QtCore.QRegularExpression(r"/handlerthree")
def test_append_path(self):
path = QgsServerApiUtils.appendMapParameter(
'/wfs3', QtCore.QUrl('https://www.qgis.org/wfs3?MAP=/some/path'))
self.assertEquals(path, '/wfs3?MAP=/some/path')
def qInitResources():
QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
def qCleanupResources():
QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name,
qt_resource_data)
def qInitResources():
QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name,
qt_resource_data)
def setMask(self):
"""
REGEx closely related to the valid chars method 'setValidCharacters'
"""
if self.scaleCombo.currentText() == '1000k':
regex = QtCore.QRegExp('[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}')
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '500k':
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}')
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '250k':
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}')
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '100k':
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}'
)
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '50k':
self.inomLineEdit.setInputMask('NN-NN-N-N-Nnn-0')
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}'
)
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '25k':
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}'
)
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '10k':
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}\-[A-Fa-f]{1}'
)
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '5k':
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}\-[A-Fa-f]{1}\-[IViv]{1,3}'
)
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '2k':
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}\-[A-Fa-f]{1}\-[IViv]{1,3}\-[1-6]{1}'
)
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
elif self.scaleCombo.currentText() == '1k':
regex = QtCore.QRegExp(
'[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}\-[A-Fa-f]{1}\-[IViv]{1,3}\-[1-6]{1}\-[A-Da-d]{1}'
)
validator = QtGui.QRegExpValidator(regex, self.inomLineEdit)
self.inomLineEdit.setValidator(validator)
def qCleanupResources():
QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
class Communicate(QtCore.QObject):
M = QtCore.pyqtSignal()
