def processAlgorithm(self, progress):
layers = self.getParameterValue(self.INPUT_DATASOURCES)
query = self.getParameterValue(self.INPUT_QUERY)
uid_field = self.getParameterValue(self.INPUT_UID_FIELD)
geometry_field = self.getParameterValue(self.INPUT_GEOMETRY_FIELD)
geometry_type = self.getParameterValue(self.INPUT_GEOMETRY_TYPE)
geometry_crs = self.getParameterValue(self.INPUT_GEOMETRY_CRS)
df = QgsVirtualLayerDefinition()
layerIdx = 1
if layers:
for layerSource in layers.split(';'):
layer = dataobjects.getObjectFromUri(layerSource)
if layer:
df.addSource('input{}'.format(layerIdx), layer.id())
if query == '':
raise GeoAlgorithmExecutionException(
self.
tr('Empty SQL. Please enter valid SQL expression and try again.'
))
else:
df.setQuery(query)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWKBTypes.NoGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs:
crs = QgsCoordinateReferenceSystem(geometry_crs)
if crs.isValid():
df.setGeometrySrid(crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise GeoAlgorithmExecutionException(
vLayer.dataProvider().error().message())
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
vLayer.pendingFields().toList(),
# Create a point layer (without any points) if 'no geometry' is chosen
vLayer.wkbType() if geometry_type != 1 else 1,
vLayer.crs())
features = vector.features(vLayer)
total = 100.0 / len(features) if len(features) > 0 else 1
outFeat = QgsFeature()
for current, inFeat in enumerate(features):
outFeat.setAttributes(inFeat.attributes())
if geometry_type != 1:
outFeat.setGeometry(inFeat.geometry())
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
def processAlgorithm(self, feedback):
layers = self.getParameterValue(self.INPUT_DATASOURCES)
query = self.getParameterValue(self.INPUT_QUERY)
uid_field = self.getParameterValue(self.INPUT_UID_FIELD)
geometry_field = self.getParameterValue(self.INPUT_GEOMETRY_FIELD)
geometry_type = self.getParameterValue(self.INPUT_GEOMETRY_TYPE)
geometry_crs = self.getParameterValue(self.INPUT_GEOMETRY_CRS)
df = QgsVirtualLayerDefinition()
layerIdx = 1
if layers:
for layerSource in layers.split(';'):
layer = dataobjects.getObjectFromUri(layerSource)
if layer:
df.addSource('input{}'.format(layerIdx), layer.id())
layerIdx += 1
if query == '':
raise GeoAlgorithmExecutionException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
else:
df.setQuery(query)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NullGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs:
crs = QgsCoordinateReferenceSystem(geometry_crs)
if crs.isValid():
df.setGeometrySrid(crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise GeoAlgorithmExecutionException(vLayer.dataProvider().error().message())
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
vLayer.fields().toList(),
# Create a point layer (without any points) if 'no geometry' is chosen
vLayer.wkbType() if geometry_type != 1 else 1,
vLayer.crs())
features = vector.features(vLayer)
total = 100.0 / len(features)
outFeat = QgsFeature()
for current, inFeat in enumerate(features):
outFeat.setAttributes(inFeat.attributes())
if geometry_type != 1:
outFeat.setGeometry(inFeat.geometry())
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, context, feedback):
layers = self.getParameterValue(self.INPUT_DATASOURCES)
query = self.getParameterValue(self.INPUT_QUERY)
uid_field = self.getParameterValue(self.INPUT_UID_FIELD)
geometry_field = self.getParameterValue(self.INPUT_GEOMETRY_FIELD)
geometry_type = self.getParameterValue(self.INPUT_GEOMETRY_TYPE)
geometry_crs = self.getParameterValue(self.INPUT_GEOMETRY_CRS)
df = QgsVirtualLayerDefinition()
layerIdx = 1
if layers:
for layerSource in layers.split(';'):
layer = QgsProcessingUtils.mapLayerFromString(layerSource, context)
if layer:
df.addSource('input{}'.format(layerIdx), layer.id())
layerIdx += 1
if query == '':
raise GeoAlgorithmExecutionException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
else:
df.setQuery(query)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NullGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs:
crs = QgsCoordinateReferenceSystem(geometry_crs)
if crs.isValid():
df.setGeometrySrid(crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise GeoAlgorithmExecutionException(vLayer.dataProvider().error().message())
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(vLayer.fields(),
vLayer.wkbType() if geometry_type != 1 else 1,
vLayer.crs(), context)
features = QgsProcessingUtils.getFeatures(vLayer, context)
total = 100.0 / QgsProcessingUtils.featureCount(vLayer, context)
outFeat = QgsFeature()
for current, inFeat in enumerate(features):
outFeat.setAttributes(inFeat.attributes())
if geometry_type != 1:
outFeat.setGeometry(inFeat.geometry())
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
def find(self, to_find):
if self.settings.value("qftsfilepath") == '':
return
if not self.isValid:
self.message.emit("Cannot search in project. QuickFinder file is probably currently in use.",QgsMessageBar.WARNING)
return
# add star after each word except numbers
to_find = to_find.split(' ')
for i,word in enumerate(to_find):
try:
int(word)
except ValueError:
to_find[i] = '%%%s%%' % word
to_find = ' '.join(to_find)
# FTS request
sql = "SELECT search_id,content,x,y,wkb_geom FROM quickfinder_data WHERE content LIKE ?"
cur = self.conn.cursor()
catLimit = self.settings.value("categoryLimit")
totalLimit = self.settings.value("totalLimit")
catFound = {}
for row in cur.execute(sql, [to_find]):
search_id, content, x, y, wkb_geom = row
if search_id in catFound:
if catFound[search_id] >= catLimit:
continue
catFound[search_id] += 1
else:
catFound[search_id] = 1
if search_id not in self._searches:
continue
gs = self._searches[search_id].geometryStorage
geometry = QgsGeometry()
if gs == 'wkb':
geometry.fromWkb(binascii.a2b_hex(wkb_geom))
else:
# wkt or extent are stored as wkt
geometry = geometry.fromWkt(wkb_geom)
crs = QgsCoordinateReferenceSystem()
crs.createFromString(self._searches[search_id].srid)
self.result_found.emit(self,
self._searches[search_id].searchName,
content,
geometry,
crs.postgisSrid())
if sum(catFound.values()) >= totalLimit:
break
def find(self, to_find):
if self.settings.value("qftsfilepath") == '':
return
if not self.isValid:
self.message.emit("Cannot search in project. QuickFinder file is probably currently in use.",QgsMessageBar.WARNING)
return
# add star after each word except numbers
to_find = to_find.split(' ')
for i,word in enumerate(to_find):
try:
int(word)
except ValueError:
to_find[i] = '%s*' % word
to_find = ' '.join(to_find)
# FTS request
sql = "SELECT search_id,content,x,y,wkb_geom FROM quickfinder_data WHERE content MATCH ?"
cur = self.conn.cursor()
catLimit = self.settings.value("categoryLimit")
totalLimit = self.settings.value("totalLimit")
catFound = {}
for row in cur.execute(sql, [to_find]):
search_id, content, x, y, wkb_geom = row
if catFound.has_key(search_id):
if catFound[search_id] >= catLimit:
continue
catFound[search_id] += 1
else:
catFound[search_id] = 1
if not self._searches.has_key(search_id):
continue
gs = self._searches[search_id].geometryStorage
geometry = QgsGeometry()
if gs == 'wkb':
geometry.fromWkb(binascii.a2b_hex(wkb_geom))
else:
# wkt or extent are stored as wkt
geometry = geometry.fromWkt(wkb_geom)
crs = QgsCoordinateReferenceSystem()
crs.createFromString(self._searches[search_id].srid)
self.result_found.emit(self,
self._searches[search_id].searchName,
content,
geometry,
crs.postgisSrid())
if sum(catFound.values()) >= totalLimit:
break
def record_clicked(self):
"""record clicked signal"""
# disable only service buttons
self.reset_buttons(True, False, False)
self.rubber_band.reset()
if not self.treeRecords.selectedItems():
return
item = self.treeRecords.currentItem()
if not item:
return
identifier = get_item_data(item, 'identifier')
try:
record = next(item for item in self.catalog.records()
if item['identifier'] == identifier)
except KeyError:
QMessageBox.warning(self,
self.tr('Record parsing error'),
'Unable to locate record identifier')
return
# if the record has a bbox, show a footprint on the map
if record['bbox'] is not None:
bx = record['bbox']
rt = QgsRectangle(float(bx['minx']), float(bx['miny']),
float(bx['maxx']), float(bx['maxy']))
geom = QgsGeometry.fromRect(rt)
if geom is not None:
src = QgsCoordinateReferenceSystem("EPSG:4326")
dst = self.map.mapSettings().destinationCrs()
if src.postgisSrid() != dst.postgisSrid():
ctr = QgsCoordinateTransform(
src, dst, QgsProject.instance())
try:
geom.transform(ctr)
except Exception as err:
QMessageBox.warning(
self,
self.tr('Coordinate Transformation Error'),
str(err))
self.rubber_band.setToGeometry(geom, None)
# figure out if the data is interactive and can be operated on
self.find_services(record, item)
def record_clicked(self):
"""record clicked signal"""
# disable only service buttons
self.reset_buttons(True, False, False)
if not self.treeRecords.selectedItems():
return
item = self.treeRecords.currentItem()
if not item:
return
identifier = get_item_data(item, 'identifier')
try:
record = self.catalog.records[identifier]
except KeyError as err:
QMessageBox.warning(self,
self.tr('Record parsing error'),
'Unable to locate record identifier')
return
# if the record has a bbox, show a footprint on the map
if record.bbox is not None:
points = bbox_to_polygon(record.bbox)
if points is not None:
src = QgsCoordinateReferenceSystem(4326)
dst = self.map.mapSettings().destinationCrs()
geom = QgsGeometry.fromPolygon(points)
if src.postgisSrid() != dst.postgisSrid():
ctr = QgsCoordinateTransform(src, dst)
try:
geom.transform(ctr)
except Exception as err:
QMessageBox.warning(
self,
self.tr('Coordinate Transformation Error'),
unicode(err))
self.rubber_band.setToGeometry(geom, None)
# figure out if the data is interactive and can be operated on
self.find_services(record, item)
def find(self, toFind):
if self.settings.value("qftsfilepath") == "":
return
if not self.isValid:
self.message.emit(
"Cannot search in project. QuickFinder file is probably currently in use.", QgsMessageBar.WARNING
)
return
# add star after each word except numbers
toFind = toFind.split(" ")
for i, word in enumerate(toFind):
try:
int(word)
except ValueError:
toFind[i] = "%s*" % word
toFind = " ".join(toFind)
# FTS request
sql = "SELECT search_id,content,x,y,wkb_geom FROM quickfinder_data WHERE content MATCH ?"
cur = self.conn.cursor()
cur.execute(sql, [toFind])
catLimit = self.settings.value("categoryLimit")
totalLimit = self.settings.value("totalLimit")
nFound = 0
catFound = {}
while True:
s = cur.fetchone()
if s is None:
return
search_id, content, x, y, wkb_geom = s
if catFound.has_key(search_id):
if catFound[search_id] >= catLimit:
continue
catFound[search_id] += 1
else:
catFound[search_id] = 1
if not self._searches.has_key(search_id):
continue
geometry = QgsGeometry()
geometry.fromWkb(binascii.a2b_hex(wkb_geom))
crs = QgsCoordinateReferenceSystem()
crs.createFromString(self._searches[search_id].srid)
self.resultFound.emit(self, self._searches[search_id].searchName, content, geometry, crs.postgisSrid())
nFound += 1
if nFound >= totalLimit:
break
class TECView:
"""QGIS Plugin Implementation."""
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 = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'TECView_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&SRH2D_TECViewer')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'TECView')
self.toolbar.setObjectName(u'TECView')
self.all_Attrs = list()
self.dlg = TECViewDialog()
self.dlg.fileListWidget.clear()
self.dlg.attributeList.clear()
self.dlg.progressBar.setVisible(False)
# - Button Connections - #
self.dlg.selectProjFolder.clicked.connect(self.selectProjFolder)
self.dlg.geoRefBtn.clicked.connect(self.selectCrs)
self.dlg.addFileBtn.clicked.connect(self.selectTECFile)
self.dlg.deleteFileBtn.clicked.connect(self.removeTECfile)
self.dlg.fileListWidget.itemSelectionChanged.connect(self.showAttr)
self.dlg.cancelLoadBtn.clicked.connect(lambda: self.dlg.done(0))
self.dlg.attributeList.clicked.connect(self.selectToShow)
self.dlg.loadTECBtn.clicked.connect(self.loadTECfiles)
self.dlg.callSettingsBtn.clicked.connect(self.runSettings)
self.dlg.fileListWidget.customContextMenuRequested.connect(
self.subMenuOnFileList)
self.animation = makeAnimation(self.iface)
self.profiler = profilePlot(self.iface)
self.contourPlot = contourPlot(self.iface)
self.makeKml = kmlExport(self.iface)
self.vecPlot = vecPlot(self.iface)
self.settings = QSettings('ManySplendid', 'SRH2D_TEC_Viewer')
try:
self.systemCRS = self.settings.value('crs')
except (AttributeError):
self.settings.setValue('crs', 3826)
crsType = QgsCoordinateReferenceSystem.InternalCrsId
self.systemCRS = QgsCoordinateReferenceSystem(3826, crsType)
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('TECView', message)
def add_action(self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
# Create the dialog (after translation) and keep reference
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(self.menu, action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
readerIcon = os.path.join(self.plugin_dir, 'icon.png')
self.add_action(
readerIcon,
text=self.tr(
u'SRH2D Post-Processing TEC File Viewer and analyser.'),
callback=self.run,
parent=self.iface.mainWindow())
profileIcon = os.path.join(self.plugin_dir, '0cs_extract-01.png')
self.add_action(profileIcon,
text=self.tr(u'Profile Viewer'),
callback=self.profiler.run,
parent=self.iface.mainWindow())
contourIcon = os.path.join(self.plugin_dir, '0contour-01.png')
self.add_action(contourIcon,
text=self.tr(u'Plot Contour'),
callback=self.contourPlot.run,
parent=self.iface.mainWindow())
toKmlIcon = os.path.join(self.plugin_dir, '0KML_contour-01.png')
self.add_action(toKmlIcon,
text=self.tr(u'Export to .kml'),
callback=self.makeKml.run,
parent=self.iface.mainWindow())
flowDirIcon = os.path.join(self.plugin_dir, '0flow_field-01.png')
self.add_action(flowDirIcon,
text=self.tr(u'Flow Direction'),
callback=self.vecPlot.run,
parent=self.iface.mainWindow())
animationIcon = os.path.join(self.plugin_dir, '0animate-01.png')
self.add_action(animationIcon,
text=self.tr(u'Make Aniamtion'),
callback=self.animation.run,
parent=self.iface.mainWindow())
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(self.tr(u'&SRH2D_TECViewer'), action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
def run(self):
"""Run method that performs all the real work"""
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result == 1:
self.settings.setValue('projFolder',
toUnicode(self.dlg.projFolderEdit.text()))
profileDiag = profilePlot(self.iface,
toUnicode(
self.dlg.projFolderEdit.text()),
TEC_Box=self.TEC_Container)
profileDiag.run()
def selectProjFolder(self):
try:
presetFolder = self.dlg.projFolderEdit.text()
except (KeyError):
presetFolder = ''
caption = 'Please choose a project folder'
folderName = QFileDialog.getExistingDirectory(self.dlg, caption,
presetFolder)
self.dlg.projFolderEdit.setText(toUnicode(folderName))
def selectCrs(self):
crsDiag = QgsGenericProjectionSelector()
crsDiag.exec_()
crsId = crsDiag.selectedCrsId()
if crsId:
crsType = QgsCoordinateReferenceSystem.InternalCrsId
self.systemCRS = QgsCoordinateReferenceSystem(crsId, crsType)
self.settings.setValue('crs', self.systemCRS.postgisSrid())
def selectTECFile(self):
Caption = 'Please select a _TEC_.dat file or multiple files'
projFolder = toUnicode(self.dlg.projFolderEdit.text())
filePathes = QFileDialog.getOpenFileNames(
self.dlg, Caption, os.path.join(projFolder, 'sim'), "*.dat")
for path in filePathes:
path = toUnicode(path)
fileWidget = TECfile(self.dlg.fileListWidget, 0, toUnicode(path),
self.iface)
self.dlg.fileListWidget.addItem(fileWidget)
def removeTECfile(self):
selectedTEC = self.dlg.fileListWidget.currentItem()
c_row = self.dlg.fileListWidget.row(selectedTEC)
self.dlg.fileListWidget.takeItem(c_row)
def showAttr(self):
self.dlg.attributeList.clear()
current = self.dlg.fileListWidget.currentItem()
attributes = current.attributes
for attr in attributes:
item = QListWidgetItem(attr[0], self.dlg.attributeList)
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
if attr[1] == 0:
item.setCheckState(Qt.Unchecked)
else:
item.setCheckState(Qt.Checked)
self.dlg.attributeList.addItem(item)
def changeAttrToOutput(self, TECitem, attr):
idx = [r for r, j in zip(count(), TECitem.attributes) if attr in j][0]
TECitem.attributes[idx][1] = 1
def changeAttrToCancel(self, TECitem, attr):
idx = [r for r, j in zip(count(), TECitem.attributes) if attr in j][0]
TECitem.attributes[idx][1] = 0
def selectToShow(self):
attrList = self.dlg.attributeList
for i in range(0, attrList.count()):
attrItem = attrList.item(i)
attrName = attrItem.text()
if attrItem.checkState() == Qt.Checked:
if self.dlg.chageAllBtn.isChecked():
for t in range(0, self.dlg.fileListWidget.count()):
TECitem = self.dlg.fileListWidget.item(t)
self.changeAttrToOutput(TECitem, attrName)
else:
TECitem = self.dlg.fileListWidget.currentItem()
self.changeAttrToOutput(TECitem, attrName)
else:
if self.dlg.chageAllBtn.isChecked():
for t in range(0, self.dlg.fileListWidget.count()):
TECitem = self.dlg.fileListWidget.item(t)
self.changeAttrToCancel(TECitem, attrName)
else:
TECitem = self.dlg.fileListWidget.currentItem()
self.changeAttrToCancel(TECitem, attrName)
def loadTECfiles(self):
projFolder = toUnicode(self.dlg.projFolderEdit.text())
outFolder = os.path.join(projFolder, u'TECView')
self.TEC_Container = list()
if not os.path.isdir(outFolder):
os.system('mkdir ' + outFolder.encode('big5'))
self.attrs()
for i in range(0, self.dlg.fileListWidget.count()):
TECitem = self.dlg.fileListWidget.item(i)
TECitem.outDir = outFolder
TECitem.iface = self.iface
TECitem.export()
item = TEClayerBox(TECitem, self.all_Attrs)
self.TEC_Container.append(item)
self.dlg.done(1)
def attrs(self):
Attrs = list()
if self.all_Attrs:
for item in self.all_Attrs:
if type(item) == str:
Attrs.append(item)
else:
Attrs.append(item[0])
else:
self.all_Attrs = list()
for t in range(0, self.dlg.fileListWidget.count()):
TECitem = self.dlg.fileListWidget.item(t)
for z in range(0, len(TECitem.attributes)):
if TECitem.attributes[z][0] not in Attrs:
Attrs.append(TECitem.attributes[z][0])
self.all_Attrs.append(TECitem.attributes[z][0])
def runSettings(self):
self.attrs()
diag = TecSettings(self.iface, self.all_Attrs)
self.all_Attrs = diag.run()
def subMenuOnFileList(self, pos):
cursorPos = self.dlg.fileListWidget.mapToGlobal(pos)
subMenu = QMenu()
subMenu.addAction('Export', self.exportTEC)
subMenu.exec_(cursorPos)
def exportTEC(self):
item = self.dlg.fileListWidget.currentItem()
folder = os.path.dirname(item.filePath)
tecName = item.fileName
self.iface.messageBar().pushMessage('Export ' + tecName + ' to ' +
folder)
allItem = self.dlg.fileListWidget.selectedItems()
def to_representation(self, instance):
ret = super(GroupSerializer, self).to_representation(instance)
# add header_logo
# before check macrogroups and groups number also if is equal to 1 use it
try:
macrogroup = instance.macrogroups.get(use_logo_client=True)
ret['header_logo_img'] = macrogroup.logo_img.name
except:
ret['header_logo_img'] = instance.header_logo_img.name
try:
macrogroup = instance.macrogroups.get(use_title_client=True)
ret['name'] = macrogroup.title
except:
# change groupData name with title for i18n app
ret['name'] = instance.title
# add crs:
crs = QgsCoordinateReferenceSystem(f'EPSG:{self.instance.srid.srid}')
# Patch for Proj4 > 4.9.3 version
if self.instance.srid.srid == 3003:
proj4 = settings.PROJ4_EPSG_3003
else:
proj4 = crs.toProj4()
ret['crs'] = {
'epsg': crs.postgisSrid(),
'proj4': proj4,
'geographic': crs.isGeographic(),
'axisinverted': crs.hasAxisInverted()
}
# map controls
ret['mapcontrols'] = [
mapcontrol.name for mapcontrol in instance.mapcontrols.all()
]
# add projects to group
ret['projects'] = []
self.projects = {}
anonymous_user = get_user_model().get_anonymous()
for g3wProjectApp in settings.G3WADMIN_PROJECT_APPS:
Project = apps.get_app_config(g3wProjectApp).get_model('project')
projects = get_objects_for_user(self.request.user, '{}.view_project'.format(g3wProjectApp), Project) \
.filter(group=instance)
projects_anonymous = get_objects_for_user(
anonymous_user, '{}.view_project'.format(g3wProjectApp),
Project).filter(group=instance)
projects = list(set(projects) | set(projects_anonymous))
for project in projects:
self.projects[g3wProjectApp + '-' + str(project.id)] = project
if project.pk == int(
self.projectId) and g3wProjectApp == self.projectType:
self.project = project
# project thumbnail
project_thumb = project.thumbnail.name if bool(project.thumbnail.name) \
else '{}client/images/FakeProjectThumb.png'.format(settings.STATIC_URL)
# Get project url
if project.url_alias:
url = reverse('group-project-map-alias',
args=[project.url_alias])[1:]
else:
url = reverse(
'group-project-map',
args=[project.group.slug, g3wProjectApp,
project.pk])[1:]
ret['projects'].append({
'id':
project.id,
'title':
project.title,
'description':
project.description,
'thumbnail':
project_thumb,
'type':
g3wProjectApp,
'gid':
"{}:{}".format(g3wProjectApp, project.id),
'modified':
project.modified.timestamp() if hasattr(
project, 'modified') else 0,
'url':
url
})
# baselayers
ret['baselayers'] = []
baselayers = instance.baselayers.all().order_by('order')
for baselayer in baselayers:
ret['baselayers'].append(BaseLayerSerializer(baselayer).data)
# add vendorkeys if it is set into settings
if settings.VENDOR_KEYS:
ret['vendorkeys'] = settings.VENDOR_KEYS
# add initproject and overviewproject
ret['initproject'] = "{}:{}".format(self.projectType, self.projectId)
# add overviewproject is present
overviewproject = instance.project_panoramic.all()
if overviewproject:
overviewproject = overviewproject[0]
ret['overviewproject'] = {
'id':
int(overviewproject.project_id),
'type':
overviewproject.project_type,
'gid':
"{}:{}".format(overviewproject.project_type,
overviewproject.project_id)
}
else:
ret['overviewproject'] = None
ret['plugins'] = {}
# Plugins/Module data
# Data from plugins can be instance of dict or list
# - dict results are used only for update 'plugins' API return data
# - list results are more verbose and action on 'plugins' API section is declared, ie:
# {
# 'mode': 'delete',
# 'data': [<list_plugins_section_to_remove>]
# },
# {
# 'mode': 'update',
# 'data': {
# '<lugins_name>: {
# ...
# }
# }
# }
plugins = initconfig_plugin_start.send(sender=self,
project=self.projectId,
projectType=self.projectType)
for data_plugin in plugins:
if data_plugin[1] and isinstance(data_plugin[1], dict):
ret['plugins'] = copy(ret['plugins'])
ret['plugins'].update(data_plugin[1])
elif data_plugin[1] and isinstance(data_plugin[1], list):
for dp in data_plugin[1]:
if dp['mode'] == 'delete':
ret['plugins'] = copy(ret['plugins'])
for k in dp['data']:
try:
ret['plugins'].pop(k)
except:
pass
elif dp['mode'] == 'update':
ret['plugins'] = copy(ret['plugins'])
ret['plugins'].update(dp['data'])
# powerd_by
ret['powered_by'] = settings.G3WSUITE_POWERD_BY
# header customs links
header_custom_links = getattr(settings,
'G3W_CLIENT_HEADER_CUSTOM_LINKS', None)
ret['header_custom_links'] = []
if header_custom_links:
# check for possible callback
for head_link in header_custom_links:
if callable(head_link):
ret['header_custom_links'].append(head_link(self.request))
else:
ret['header_custom_links'].append(head_link)
# custom layout
ret['layout'] = {}
# add legend settings if set to layout
layout_legend = getattr(settings, 'G3W_CLIENT_LEGEND', None)
if layout_legend:
ret['layout']['legend'] = layout_legend
# Check if G3W_CLIENT_LEGEND['layertitle'] set it tu false
if self.project.legend_position == 'toc':
if layout_legend:
ret['layout']['legend']['layertitle'] = False
else:
ret['layout']['legend'] = {'layertitle': False}
# add legend settings if set to layout
layout_right_panel = getattr(settings, 'G3W_CLIENT_RIGHT_PANEL', None)
if layout_right_panel:
ret['layout']['rightpanel'] = layout_right_panel
return ret
def to_representation(self, instance):
ret = super(LayerSerializer, self).to_representation(instance)
qgs_maplayer = self.qgs_project.mapLayers()[instance.qgs_layer_id]
group = instance.project.group
# add attributes/fields
ret['fields'] = self.get_attributes(instance)
# add infoformat and infourl
ret['infoformat'] = ''
ret['infourl'] = ''
lidname = instance.qgs_layer_id if instance.project.wms_use_layer_ids else instance.name
# add bbox
if instance.geometrytype != QGIS_LAYER_TYPE_NO_GEOM:
if instance.extent:
ret['bbox'] = instance.extent_rect
else:
# get from QgsMapLayer instance
extent = qgs_maplayer.extent()
ret['bbox'] = {}
ret['bbox']['minx'] = extent.xMinimum()
ret['bbox']['miny'] = extent.yMinimum()
ret['bbox']['maxx'] = extent.xMaximum()
ret['bbox']['maxy'] = extent.yMaximum()
# add capabilities
ret['capabilities'] = get_capabilities4layer(qgs_maplayer)
# add styles
# FIXME: restore in the future for styles map management
#ret['styles'] = self.qgis_projectsettings_wms.layers[lidname]['styles']
ret['source'] = {'type': instance.layer_type}
# add options for wms layer
if instance.layer_type in [
Layer.TYPES.wms, Layer.TYPES.arcgismapserver
]:
if instance.layer_type == Layer.TYPES.wms:
datasourceWMS = QueryDict(instance.datasource)
else:
datasourceWMS = datasourcearcgis2dict(instance.datasource)
if ('username' not in ret['source'] or 'password' not in ret['source']) and 'type=xyz' \
not in instance.datasource:
# rebuild the dict for paramenters repeat n times i.e. 'layers' and 'styles'
if isinstance(datasourceWMS, QueryDict):
for p in datasourceWMS.lists():
if p[0] in ('layers', 'styles'):
ret['source'].update({p[0]: ','.join(p[1])})
else:
ret['source'].update({p[0]: datasourceWMS[p[0]]})
else:
ret['source'].update(datasourceWMS)
ret['source']['external'] = instance.external
# replace crs property if is not none with dict structure
if ret['crs']:
crs = QgsCoordinateReferenceSystem(f'EPSG:{ret["crs"]}')
ret['crs'] = {
'epsg': crs.postgisSrid(),
'proj4': crs.toProj4(),
'geographic': crs.isGeographic(),
'axisinverted': crs.hasAxisInverted()
}
# add metadata
ret['metadata'] = self.get_metadata(instance, qgs_maplayer)
# eval editor_form_structure
if ret['editor_form_structure']:
ret['editor_form_structure'] = eval(instance.editor_form_structure)
# add ows
ret['ows'] = self.get_ows(instance)
return ret
def convert_sde_sdc_workspace(
name, # pylint: disable=too-many-branches,too-many-statements
workspace_name: WorkspaceName,
base: str,
crs: QgsCoordinateReferenceSystem,
subset: str,
context: Context,
is_sdc: bool) -> DataSourceProperties:
"""
Convert SdeWorkspaceFactory/SdcWorkspaceFactory
"""
file_name = ConversionUtils.get_absolute_path(workspace_name.name,
base)
uri = None
wkb_type = None
connection = None
if not is_sdc:
sde_path = Path(file_name)
if workspace_name.connection_properties:
connection = ConnectionConverter.convert_connection(
workspace_name.connection_properties, context)
elif sde_path.exists() and not sde_path.is_dir():
connection = ConnectionConverter.convert_sde_connection(
sde_path, context)
if connection is not None:
sde_uri, provider = connection
# what happens if there's more than one . ???
if provider == 'oracle':
parts = DatasetNameConverter.split_to_tokens(name.name)
if len(parts) == 2:
sde_uri.setSchema(parts[0])
sde_uri.setTable(
DatasetNameConverter.convert_sde_table_name(
parts[1], context))
if not isinstance(name, TableName):
sde_uri.setSrid(str(crs.postgisSrid()))
wkb_type = DatasetNameConverter.GEOMETRY_TYPE_TO_WKB_TYPE[
name.shape_type]
sde_uri.setWkbType(wkb_type)
sde_uri.setGeometryColumn(name.shape_field_name)
else:
sde_uri.setWkbType(QgsWkbTypes.NoGeometry)
sde_uri.setSql(subset)
sde_uri.setKeyColumn(context.sde_primary_key)
uri = sde_uri.uri()
file_name = None
else:
context.unsupported_object_callback(
f'Could not convert Oracle table name {name.name}. Please email this file to [email protected] so that we can add support in a future SLYR release.',
level=Context.CRITICAL)
elif provider == 'mssql':
parts = DatasetNameConverter.split_to_tokens(name.name)
if len(parts) == 3:
sde_uri.setSchema(parts[1])
sde_uri.setTable(
DatasetNameConverter.convert_sde_table_name(
parts[2], context))
if not isinstance(name, TableName):
sde_uri.setSrid(str(crs.postgisSrid()))
wkb_type = DatasetNameConverter.GEOMETRY_TYPE_TO_WKB_TYPE[
name.shape_type]
sde_uri.setWkbType(wkb_type)
sde_uri.setGeometryColumn(name.shape_field_name)
else:
sde_uri.setWkbType(QgsWkbTypes.NoGeometry)
sde_uri.setSql(subset)
sde_uri.setKeyColumn(context.sde_primary_key)
uri = sde_uri.uri()
file_name = None
else:
context.unsupported_object_callback(
f'Could not convert SQL Server table name {name.name}. Please email this file to [email protected] so that we can add support in a future SLYR release.',
level=Context.CRITICAL)
elif provider == 'postgres':
parts = DatasetNameConverter.split_to_tokens(name.name)
if len(parts) == 3:
sde_uri.setSchema(parts[1])
sde_uri.setTable(
DatasetNameConverter.convert_sde_table_name(
parts[2], context))
if not isinstance(name, TableName):
sde_uri.setSrid(str(crs.postgisSrid()))
wkb_type = DatasetNameConverter.GEOMETRY_TYPE_TO_WKB_TYPE[
name.shape_type]
sde_uri.setWkbType(wkb_type)
sde_uri.setGeometryColumn(name.shape_field_name)
else:
sde_uri.setWkbType(QgsWkbTypes.NoGeometry)
sde_uri.setSql(subset)
sde_uri.setKeyColumn(context.sde_primary_key)
uri = sde_uri.uri()
file_name = None
else:
context.unsupported_object_callback(
f'Could not convert PostgreSQL table name {name.name}. Please email this file to [email protected] so that we can add support in a future SLYR release.',
level=Context.CRITICAL)
else:
provider = 'ogr'
if name.__class__.__name__ in ('DBTableName', 'TableName'):
wkb_type = QgsWkbTypes.NoGeometry
else:
wkb_type = DatasetNameConverter.geometry_type_to_wkb(
name.shape_type)
if not is_sdc:
uri = '{}|layername={}'.format(file_name, name.name)
else:
file_name = ConversionUtils.get_absolute_path(
name.name, file_name)
uri = file_name
return DataSourceProperties(uri=uri,
wkb_type=wkb_type,
provider=provider,
file_name=file_name)
def to_representation(self, instance):
ret = super(LayerSerializer, self).to_representation(instance)
qgs_maplayer = self.qgs_project.mapLayers()[instance.qgs_layer_id]
# add attributes/fields
ret['fields'] = self.get_attributes(instance)
# add infoformat and infourl
ret['infoformat'] = ''
ret['infourl'] = ''
#lidname = instance.qgs_layer_id if instance.project.wms_use_layer_ids else instance.name
# add bbox
if instance.geometrytype != QGIS_LAYER_TYPE_NO_GEOM:
if instance.extent:
ret['bbox'] = instance.extent_rect
else:
# get from QgsMapLayer instance
extent = qgs_maplayer.extent()
ret['bbox'] = {}
ret['bbox']['minx'] = extent.xMinimum()
ret['bbox']['miny'] = extent.yMinimum()
ret['bbox']['maxx'] = extent.xMaximum()
ret['bbox']['maxy'] = extent.yMaximum()
# add capabilities
ret['capabilities'] = get_capabilities4layer(qgs_maplayer)
# add styles
# FIXME: restore in the future for styles map management
#ret['styles'] = self.qgis_projectsettings_wms.layers[lidname]['styles']
ret['source'] = {'type': instance.layer_type}
# add options for wms layer
if instance.layer_type in [
Layer.TYPES.wms, Layer.TYPES.arcgismapserver
]:
if instance.layer_type == Layer.TYPES.wms:
datasource_wms = QueryDict(instance.datasource)
else:
datasource_wms = datasourcearcgis2dict(instance.datasource)
if ('username' not in ret['source'] or 'password' not in ret['source']) and 'type=xyz' \
not in instance.datasource:
# rebuild the dict for paramenters repeat n times i.e. 'layers' and 'styles'
if isinstance(datasource_wms, QueryDict):
for p in datasource_wms.lists():
if p[0] in ('layers', 'styles'):
ret['source'].update({p[0]: ','.join(p[1])})
else:
ret['source'].update({p[0]: datasource_wms[p[0]]})
else:
ret['source'].update(datasource_wms)
ret['source']['external'] = instance.external
if instance.external and instance.layer_type == Layer.TYPES.wms:
try:
wms = WebMapService(ret['source']['url'], version='1.3.0')
format_options = wms.getOperationByName(
'GetFeatureInfo').formatOptions
if format_options:
# Filter format by supported by G3W-CLIENT
formats = list(
set(format_options).intersection(
set(settings.EXTERNAL_WMS_INFOFORMATS_SUPPORTED
)))
if formats:
ret['infoformat'] = formats[0]
ret['infoformats'] = formats
except Exception as e:
logger.debug(
f'WMS layer GetFeatureInfo formats available: {e}')
# replace crs property if is not none with dict structure
if ret['crs']:
crs = QgsCoordinateReferenceSystem(f'EPSG:{ret["crs"]}')
# Patch for Proj4 > 4.9.3 version
if ret["crs"] == 3003:
proj4 = "+proj=tmerc +lat_0=0 +lon_0=9 +k=0.9996 +x_0=1500000 +y_0=0 +ellps=intl " \
"+towgs84=-104.1,-49.1,-9.9,0.971,-2.917,0.714,-11.68 +units=m +no_defs"
else:
proj4 = crs.toProj4()
ret['crs'] = {
'epsg': crs.postgisSrid(),
'proj4': proj4,
'geographic': crs.isGeographic(),
'axisinverted': crs.hasAxisInverted()
}
# add metadata
ret['metadata'] = self.get_metadata(instance, qgs_maplayer)
# eval editor_form_structure
if ret['editor_form_structure']:
ret['editor_form_structure'] = eval(instance.editor_form_structure)
# add ows
ret['ows'] = self.get_ows(instance)
# For temporal properties
if instance.temporal_properties:
ret['qtimeseries'] = json.loads(instance.temporal_properties)
if ret['qtimeseries'] and ret['qtimeseries'][
'mode'] == 'FeatureDateTimeInstantFromField':
# Add start_date end end_date:
findex = qgs_maplayer.dataProvider().fieldNameIndex(
ret['qtimeseries']['field'])
ret['qtimeseries']['start_date'] = qgs_maplayer.minimumValue(
findex)
ret['qtimeseries']['end_date'] = qgs_maplayer.maximumValue(
findex)
if isinstance(ret['qtimeseries']['start_date'],
QDate) or isinstance(
ret['qtimeseries']['start_date'], QDateTime):
if not hasattr(QDate, 'isoformat'):
QDate.isoformat = lambda d: d.toString(Qt.ISODate)
if not hasattr(QDateTime, 'isoformat'):
QDateTime.isoformat = lambda d: d.toString(
Qt.ISODateWithMs)
ret['qtimeseries']['start_date'] = ret['qtimeseries'][
'start_date'].isoformat()
ret['qtimeseries']['end_date'] = ret['qtimeseries'][
'end_date'].isoformat()
return ret
def run(self):
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result == 1:
# get target directory
dirName = self.dlg.ui.dirEdit.text()
# Export path field empty? Raise warning and break with return.
if dirName == "":
QtWidgets.QMessageBox.critical(self.dlg, "BulkVectorExport", \
"Please input directory name")
return
# Check for valid directory path.
if dirName[len(dirName) - 1] != "/":
dirName = dirName + "/"
if not QtCore.QFileInfo(dirName).isDir():
QtWidgets.QMessageBox.critical(self.dlg, "BulkVectorExport", \
"No such directory : " + dirName)
return
ogr_driver_name = "GeoJSON"
ogr_driver_name_raster = "GTiff"
print("Driver name: " + ogr_driver_name)
layers = qgis.utils.iface.mapCanvas().layers()
project = QgsProject.instance()
mapInfo = {
"name": os.path.basename(project.fileName()),
"layers": [],
"bounds": []
}
tempPath = tempfile.mkdtemp('bulkexport') + os.sep
fileNames = []
for layer in reversed(layers):
layerType = layer.type()
if layerType == QgsMapLayer.RasterLayer:
renderer = layer.renderer()
hasIcon = False
print('Writing: ' + str(layer.name()))
layer_filename_r = tempPath + str(uuid.uuid4()) + '.tif'
print('Filename: ' + layer_filename_r)
provider = layer.dataProvider()
src_crs = layer.crs()
dst_crs = QgsCoordinateReferenceSystem("EPSG:4326")
source_path = " -of GTiff " + provider.dataSourceUri()
cmd = "gdalwarp -overwrite -r bilinear -s_srs EPSG:" + \
str(src_crs.postgisSrid()) + \
" -t_srs EPSG:" + \
str(dst_crs.postgisSrid()) + \
" " + \
source_path + \
" " + \
layer_filename_r
result4 = os.system(cmd)
print("geotiff export Status: " + str(result4))
if result4 != 0:
QtWidgets.QMessageBox.warning(self.dlg, "BulkVectorExport",\
"Failed to export: " + layer.name() + \
"Status: " + str(result4))
result5 = False
mapInfo['layers'].append({
"title":
str(layer.name()),
"geotiff":
os.path.basename(layer_filename_r) # + '.tif'
})
fileNames.append(layer_filename_r)
elif layerType == QgsMapLayer.VectorLayer:
renderer = layer.renderer()
hasIcon = False
if isinstance(renderer, QgsSingleSymbolRenderer):
copySymbols(renderer.symbol(), tempPath, fileNames)
hasIcon = True
print('Writing:' + str(layer.name()))
layer_filename = tempPath + str(uuid.uuid4())
print('Filename: ' + layer_filename)
crs = QgsCoordinateReferenceSystem("EPSG:4326")
result2 = qgis.core.QgsVectorFileWriter.writeAsVectorFormat(
layer, layer_filename, "utf-8", crs, ogr_driver_name)
print("Status: " + str(result2))
if result2[0] != 0:
QtWidgets.QMessageBox.warning(self.dlg, "BulkVectorExport",\
"Failed to export: " + layer.name() + \
"Status: " + str(result2))
sld_filename = os.path.join(
tempPath,
os.path.basename(layer_filename) + '.sld')
print('Filename: ' + sld_filename)
result3 = False
layer.saveSldStyle(sld_filename)
mapInfo['layers'].append({
"title":
str(layer.name()),
"geojson":
os.path.basename(layer_filename) + '.geojson',
"sld":
os.path.basename(sld_filename),
## opacity value has to be rounded, otherwise python 3.6 writes 0.99 instead of 1.0
"opacity":
round(1 - (layer.opacity() / 100.0), 1),
"hasIcon":
hasIcon
})
fileNames.append(layer_filename + '.geojson')
fileNames.append(sld_filename)
print(fileNames)
## initial bounding box is visible extent
canvas = self.iface.mapCanvas()
canvasExtent = canvas.extent()
crsDest = QgsCoordinateReferenceSystem("EPSG:4326")
try:
crsSrc = canvas.mapSettings().destinationCrs()
except:
crsSrc = canvas.mapRenderer().destinationCrs()
xform = QgsCoordinateTransform(crsSrc, crsDest,
QgsProject.instance())
canvasExtentTransformed = xform.transform(canvasExtent)
initialBounds = [
canvasExtentTransformed.xMinimum(),
canvasExtentTransformed.yMinimum(),
canvasExtentTransformed.xMaximum(),
canvasExtentTransformed.yMaximum()
]
mapInfo['bounds'] = bounds(layers)
mapInfo['maxZoom'] = 11
mapInfo['minZoom'] = 6
mapInfo['description'] = ""
mapInfo['attribution'] = ""
mapInfo['popupTemplate'] = ""
mapInfo['initialBounds'] = initialBounds
mapInfo['limitedInitialBounds'] = False
mapInfo['popupLayerIndex'] = -1
mapInfo['hasLayerControl'] = True
mapInfo['hasZoomControl'] = True
mapInfo['hasLayerLegend'] = True
mapInfo['basemap'] = 'bmapgrau'
map_filename = tempPath + 'metadata.json'
with open(map_filename, 'w') as outfile:
json.dump(mapInfo, outfile)
fileNames.append(map_filename)
## if .svg file present, add to packlist
for svgfile in os.listdir(tempPath):
if svgfile.endswith(".svg"):
fileNames.append(tempPath + svgfile)
## zip all
zf = zipfile.ZipFile(
dirName + os.sep + os.path.basename(str(project.fileName())) +
'.globus.zip', "w")
for fileName in fileNames:
zf.write(os.path.join(fileName),
arcname=os.path.split(fileName)[1])
os.remove(fileName)
shutil.rmtree(tempPath, ignore_errors=True, onerror=None)
zf.close()
def to_representation(self, instance):
ret = super(GroupSerializer, self).to_representation(instance)
# add header_logo
# before check macrogroups and groups number also if is equal to 1 use it
try:
macrogroup = instance.macrogroups.get(use_logo_client=True)
ret['header_logo_img'] = macrogroup.logo_img.name
except:
ret['header_logo_img'] = instance.header_logo_img.name
try:
macrogroup = instance.macrogroups.get(use_title_client=True)
ret['name'] = macrogroup.title
except:
# change groupData name with title for i18n app
ret['name'] = instance.title
# add crs:
crs = QgsCoordinateReferenceSystem(f'EPSG:{self.instance.srid.srid}')
ret['crs'] = {
'epsg': crs.postgisSrid(),
'proj4': crs.toProj4(),
'geographic': crs.isGeographic(),
'axisinverted': crs.hasAxisInverted()
}
# map controls
ret['mapcontrols'] = [
mapcontrol.name for mapcontrol in instance.mapcontrols.all()
]
# add projects to group
ret['projects'] = []
self.projects = {}
anonymous_user = get_user_model().get_anonymous()
for g3wProjectApp in settings.G3WADMIN_PROJECT_APPS:
Project = apps.get_app_config(g3wProjectApp).get_model('project')
projects = get_objects_for_user(self.request.user, '{}.view_project'.format(g3wProjectApp), Project) \
.filter(group=instance)
projects_anonymous = get_objects_for_user(
anonymous_user, '{}.view_project'.format(g3wProjectApp),
Project).filter(group=instance)
projects = list(set(projects) | set(projects_anonymous))
print(projects)
for project in projects:
self.projects[g3wProjectApp + '-' + str(project.id)] = project
if project.pk == int(
self.projectId) and g3wProjectApp == self.projectType:
self.project = project
# project thumbnail
project_thumb = project.thumbnail.name if bool(project.thumbnail.name) \
else '{}client/images/FakeProjectThumb.png'.format(settings.STATIC_URL)
ret['projects'].append({
'id':
project.id,
'title':
project.title,
'description':
project.description,
'thumbnail':
project_thumb,
'type':
g3wProjectApp,
'gid':
"{}:{}".format(g3wProjectApp, project.id),
'modified':
project.modified.timestamp() if hasattr(
project, 'modified') else 0
})
# baselayers
ret['baselayers'] = []
baselayers = instance.baselayers.all().order_by('order')
for baselayer in baselayers:
ret['baselayers'].append(BaseLayerSerializer(baselayer).data)
# add vendorkeys if it is set into settings
if settings.VENDOR_KEYS:
ret['vendorkeys'] = settings.VENDOR_KEYS
# add initproject and overviewproject
ret['initproject'] = "{}:{}".format(self.projectType, self.projectId)
# add overviewproject is present
overviewproject = instance.project_panoramic.all()
if overviewproject:
overviewproject = overviewproject[0]
ret['overviewproject'] = {
'id':
int(overviewproject.project_id),
'type':
overviewproject.project_type,
'gid':
"{}:{}".format(overviewproject.project_type,
overviewproject.project_id)
}
else:
ret['overviewproject'] = None
ret['plugins'] = {}
# plugins/module data
dataPlugins = initconfig_plugin_start.send(
sender=self, project=self.projectId, projectType=self.projectType)
for dataPlugin in dataPlugins:
if dataPlugin[1]:
ret['plugins'] = copy(ret['plugins'])
ret['plugins'].update(dataPlugin[1])
# powerd_by
ret['powered_by'] = settings.G3WSUITE_POWERD_BY
# header customs links
header_custom_links = getattr(settings,
'G3W_CLIENT_HEADER_CUSTOM_LINKS', None)
ret['header_custom_links'] = []
if header_custom_links:
# check for possible callback
for head_link in header_custom_links:
if callable(head_link):
ret['header_custom_links'].append(head_link(self.request))
else:
ret['header_custom_links'].append(head_link)
# custom layout
ret['layout'] = {}
# add legend settings if set to layout
layout_legend = getattr(settings, 'G3W_CLIENT_LEGEND', None)
if layout_legend:
ret['layout']['legend'] = layout_legend
# Check if G3W_CLIENT_LEGEND['layertitle'] set it tu false
if self.project.legend_position == 'toc':
if layout_legend:
ret['layout']['legend']['layertitle'] = False
else:
ret['layout']['legend'] = {'layertitle': False}
# add legend settings if set to layout
layout_right_panel = getattr(settings, 'G3W_CLIENT_RIGHT_PANEL', None)
if layout_right_panel:
ret['layout']['rightpanel'] = layout_right_panel
return ret
def post(self, request, **kwargs):
# Check for content type accept only 'application/json'
if request.content_type != 'application/json':
return APIException(
"Interface OWS accept only 'application/json request'")
post_data = json.loads(request.body)
# Required
url = post_data.get('url')
if not url:
raise APIException("'url' parameter must be provided.")
service = post_data.get('service')
if not service:
raise APIException("'service' parameter must be provided.")
service = service.lower()
if service not in self._service_available.keys():
raise APIException(f"Service '{service}' is not available.")
# Not required:
version = post_data.get('version', '1.3.0')
ows = self._service_available[service](url, version=version)
# Identification
# -----------------------------------
self.results.results.update({
'title': ows.identification.title,
'abstract': ows.identification.abstract
})
# Map formats
# -----------------------------------
self.results.results.update(
{'map_formats': ows.getOperationByName('GetMap').formatOptions})
# Info formats
# -----------------------------------
self.results.results.update({
'info_formats':
ows.getOperationByName('GetFeatureInfo').formatOptions
})
# Layers
# -----------------------------------
available_layers = list(ows.contents)
# add styles for every layer
layers = []
for al in available_layers:
# Build crs
crss = []
for srid in ows[al].crsOptions:
crs = QgsCoordinateReferenceSystem(srid)
if crs.postgisSrid() == 3003:
proj4 = settings.PROJ4_EPSG_3003
else:
proj4 = crs.toProj4()
crss.append({
'epsg': crs.postgisSrid(),
'proj4': proj4,
'geographic': crs.isGeographic(),
'axisinverted': crs.hasAxisInverted()
})
layers.append({
'name':
al,
'title':
ows[al].title,
'abstract':
ows[al].abstract,
'crss':
crss,
'styles':
ows[al].styles,
'parent':
ows[al].parent.id if ows[al].parent else None
})
self.results.results.update({'layers': layers})
return Response(self.results.results)
