def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
host = self.parameterAsString(
parameters,
self.HOST,
context
)
port = self.parameterAsString(
parameters,
self.PORT,
context
)
database = self.parameterAsString(
parameters,
self.DATABASE,
context
)
user = self.parameterAsString(
parameters,
self.USER,
context
)
password = self.parameterAsString(
parameters,
self.PASSWORD,
context
)
layerStringList = self.parameterAsString(
parameters,
self.LAYER_LIST,
context
)
loadToCanvas = self.parameterAsBoolean(
parameters,
self.LOAD_TO_CANVAS,
context
)
uniqueLoad = self.parameterAsBoolean(
parameters,
self.UNIQUE_LOAD,
context
)
abstractDb = self.getAbstractDb(host, port, database, user, password)
inputParamList = layerStringList.split(',')
layerLoader = LayerLoaderFactory().makeLoader(
iface, abstractDb
)
if loadToCanvas:
iface.mapCanvas().freeze(True)
outputLayers = layerLoader.loadLayersInsideProcessing(
inputParamList,
uniqueLoad=uniqueLoad,
addToCanvas=loadToCanvas,
feedback=feedback
)
if loadToCanvas:
iface.mapCanvas().freeze(False)
return {self.OUTPUT: [i.id() for i in outputLayers]}
def loadFrameLayer(self):
"""
Loads the frame layer case it is not loaded yet.
"""
loader = LayerLoaderFactory().makeLoader(self.iface,
self.widget.abstractDb)
if loader.provider == 'postgres':
layerMeta = {
'cat': 'aux',
'geom': 'geom',
'geomType': 'MULTIPOLYGON',
'lyrName': 'moldura_a',
'tableName': 'aux_moldura_a',
'tableSchema': 'public',
'tableType': 'BASE TABLE'
}
elif loader.provider == 'spatialite':
layerMeta = {
'cat': 'aux',
'geom': 'GEOMETRY',
'geomType': 'MULTIPOLYGON',
'lyrName': 'moldura_a',
'tableName': 'aux_moldura_a',
'tableSchema': 'public',
'tableType': 'BASE TABLE'
}
else:
layerMeta = None
layerDict = loader.load([layerMeta], uniqueLoad=True)
if layerMeta['lyrName'] in list(layerDict.keys()):
layer = layerDict[layerMeta['lyrName']]
else:
layer = None
return layer
def getLayerLoader(self):
"""
Returns the layer loader for given datasource.
:return: (EDGVLayerLoader) layer loader.
"""
abstracDb = self.getDatasource()
return LayerLoaderFactory().makeLoader(iface=iface, abstractDb=abstracDb) if abstracDb else None
def readSpatiaLite(self, path):
"""
Reads a SpatiaLite database and gets its vector layers.
:param path: (str) path do the SpatiaLite database.
:return: (dict) map to the SpatiaLite database's layers.
"""
uri = QgsDataSourceUri()
uri.setDatabase(path)
db = self.connectToSpatialite(path)
layerLoader = LayerLoaderFactory().makeLoader(iface, db)
layers = dict()
for l in list(db.listClassesWithElementsFromDatabase([]).keys()):
layers[l] = layerLoader.getLayerByName(l)
for l in db.listComplexClassesFromDatabase():
layers[l] = layerLoader.getComplexLayerByName(l)
return layers
def getLayerLoader(self):
"""
Gets the shapefile layer loader as designed in DSGTools plugin.
LAYER LOADERS SHOULD NOT be imported in abstract db. (Shapefile AbstractDb)s are
a concept extrapolation, and this is specific for this case.
:return: (ShapefileLayerLoader) shapefile layer loader object.
"""
# DIAMOND PROBLEM ALERT: this method requires care to be used; similar methods should be avoided!
return LayerLoaderFactory().makeLoader(iface, self)
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
host = self.parameterAsString(parameters, self.HOST, context)
port = self.parameterAsString(parameters, self.PORT, context)
database = self.parameterAsString(parameters, self.DATABASE, context)
user = self.parameterAsString(parameters, self.USER, context)
password = self.parameterAsString(parameters, self.PASSWORD, context)
layerStringList = self.parameterAsString(parameters, self.LAYER_LIST,
context)
loadToCanvas = self.parameterAsBoolean(parameters, self.LOAD_TO_CANVAS,
context)
uniqueLoad = self.parameterAsBoolean(parameters, self.UNIQUE_LOAD,
context)
tableSchema = self.parameterAsString(parameters, self.SCHEMA_NAME,
context)
abstractDb = self.getAbstractDb(host, port, database, user, password)
inputParamList = [(tableSchema, i) for i in layerStringList.split(',')]
layerLoader = LayerLoaderFactory().makeLoader(iface, abstractDb)
if loadToCanvas:
iface.mapCanvas().freeze(True)
multiStepFeedback = QgsProcessingMultiStepFeedback(2, feedback)
multiStepFeedback.setCurrentStep(0)
outputLayers = layerLoader.loadLayersInsideProcessing(
inputParamList,
uniqueLoad=uniqueLoad,
addToCanvas=loadToCanvas,
nonSpatial=True,
feedback=multiStepFeedback)
multiStepFeedback.setCurrentStep(1)
output = processing.run('dsgtools:grouplayers', {
'INPUT_LAYERS':
outputLayers,
'CATEGORY_EXPRESSION':
"to_string('{name}')".format(name=tableSchema),
'OUTPUT':
':memory'
},
context=context,
feedback=multiStepFeedback)
if loadToCanvas:
iface.mapCanvas().freeze(False)
return {self.OUTPUT: [i.id() for i in outputLayers]}
def readInputLayers(self, datasourcePath, feedback=None):
"""
Reads all input datasources and return its layers.
:param datasourcePath: (str) input's datasource path.
:param feedback: (QgsProcessingMultiStepFeedback) QGIS tool for progress tracking.
:return: (dict) a map for input's layers.
"""
inputLayerMap = dict()
parameters = self.parseDatasourcePath(datasourcePath)
abstractDb = self.connectToDb(parameters=parameters)
if abstractDb is None:
return {}
layerLoader = LayerLoaderFactory().makeLoader(self.iface, abstractDb)
geometricLayers = list(
abstractDb.listClassesWithElementsFromDatabase([]).keys())
complexLayers = abstractDb.listComplexClassesFromDatabase()
if feedback is not None:
stepSize = 100 / (len(geometricLayers) +
len(complexLayers)) if len(
geometricLayers) + len(complexLayers) else 0
curr = 0
for curr, l in enumerate(geometricLayers):
if feedback is not None and feedback.isCanceled():
return inputLayerMap
vl = layerLoader.getLayerByName(l)
inputLayerMap[vl.name()] = vl
if feedback is not None:
feedback.setProgress(curr * stepSize)
for currComplex, l in enumerate(complexLayers):
if feedback is not None and feedback.isCanceled():
return inputLayerMap
vl = layerLoader.getComplexLayerByName(l)
if vl.featureCount() > 0:
inputLayerMap[vl.name()] = vl
if feedback is not None:
feedback.setProgress((curr + currComplex) * stepSize)
# after reading its layers, db connection will not be used again
del abstractDb
return inputLayerMap
def readOutputLayers(self, datasourcePath, feedback=None):
"""
Prepares output layers to be filled.
:param datasourcePath: (str) output's datasource path.
:param context: (QgsProcessingContext) environment parameters in which processing tools are used.
:param feedback: (QgsProcessingMultiStepFeedback) QGIS tool for progress tracking.
:return: (dict) a map for output's layers.
"""
parameters = self.parseDatasourcePath(datasourcePath)
abstractDb = self.connectToDb(parameters=parameters)
if abstractDb is None:
return {}
layerLoader = LayerLoaderFactory().makeLoader(self.iface, abstractDb)
outputLayerMap = dict()
geometricLayers = abstractDb.listGeomClassesFromDatabase([])
complexLayers = abstractDb.listComplexClassesFromDatabase()
if feedback is not None:
multiStepFeedback = QgsProcessingMultiStepFeedback(
len(geometricLayers) + len(complexLayers), feedback)
for curr, l in enumerate(geometricLayers):
if feedback is not None and multiStepFeedback.isCanceled():
return outputLayerMap
vl = layerLoader.getLayerByName(l)
outputLayerMap[vl.name()] = vl
if feedback is not None:
multiStepFeedback.setCurrentStep(curr)
for currComplex, l in enumerate(complexLayers):
if feedback is not None and multiStepFeedback.isCanceled():
return outputLayerMap
vl = layerLoader.getComplexLayerByName(l)
outputLayerMap[vl.name()] = vl
if feedback is not None:
multiStepFeedback.setCurrentStep(curr + currComplex)
# after reading its layers, db connection will not be used again
del abstractDb
return outputLayerMap
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
host = self.parameterAsString(parameters, self.HOST, context)
port = self.parameterAsString(parameters, self.PORT, context)
database = self.parameterAsString(parameters, self.DATABASE, context)
user = self.parameterAsString(parameters, self.USER, context)
password = self.parameterAsString(parameters, self.PASSWORD, context)
layerStringList = self.parameterAsString(parameters, self.LAYER_LIST,
context)
inputParamList = layerStringList.split(',')
layerLoader = LayerLoaderFactory().makeLoader(iface, abstractDb)
iface.mapCanvas().freeze(True)
outputLayers = layerLoader.loadLayersInsideProcessing(
inputParamList,
uniqueLoad=True,
addToCanvas=True,
feedback=feedback)
iface.mapCanvas().freeze(False)
#TODO: Resto
return {self.OUTPUT: [i.id() for i in outputLayers]}
def __init__(self, iface, parent=None):
"""
Constructor
"""
super(self.__class__, self).__init__(parent)
self.setupUi(self)
self.iface = iface
self.layerFactory = LayerLoaderFactory()
self.selectedClasses = []
self.widget.tabWidget.setTabEnabled(0,True)
self.widget.tabWidget.setTabEnabled(1,False)
self.widget.tabWidget.setCurrentIndex(0)
self.bar = QgsMessageBar()
self.setLayout(QtGui.QGridLayout(self))
self.layout().setContentsMargins(0,0,0,0)
self.layout().setAlignment(QtCore.Qt.AlignTop)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed)
self.bar.setSizePolicy(sizePolicy)
self.layout().addWidget(self.bar, 0,0,1,1)
QtCore.QObject.connect(self.widget, QtCore.SIGNAL(("problemOccurred()")), self.pushMessage)
self.widget.dbChanged.connect(self.widgetConv.setDatabase)
class LoadAuxStruct(QtWidgets.QDialog, FORM_CLASS):
def __init__(self, iface, parent=None):
"""
Constructor
"""
super(self.__class__, self).__init__(parent)
self.setupUi(self)
self.iface = iface
self.layerFactory = LayerLoaderFactory()
self.selectedClasses = []
self.widget.tabWidget.setTabEnabled(0,True)
self.widget.tabWidget.setTabEnabled(1,False)
self.widget.tabWidget.setCurrentIndex(0)
self.bar = QgsMessageBar()
self.setLayout(QtGui.QGridLayout(self))
self.layout().setContentsMargins(0,0,0,0)
self.layout().setAlignment(QtCore.Qt.AlignTop)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed)
self.bar.setSizePolicy(sizePolicy)
self.layout().addWidget(self.bar, 0,0,1,1)
QtCore.QObject.connect(self.widget, QtCore.SIGNAL(("problemOccurred()")), self.pushMessage)
self.widget.dbChanged.connect(self.widgetConv.setDatabase)
@pyqtSlot(bool)
def on_pushButtonCancel_clicked(self):
"""
Closes the dialog
"""
self.close()
def pushMessage(self, msg):
"""
Pushes a message into message bar
"""
self.bar.pushMessage("", msg, level=QgsMessageBar.CRITICAL)
@pyqtSlot(bool)
def on_pushButtonOk_clicked(self):
"""
Checks the linee-centroid structure and loads the correspondent layers
"""
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
if self.widgetConv.settingDict == dict():
QApplication.restoreOverrideCursor()
self.bar.pushMessage(self.tr("Error!"), self.tr("Could not load auxiliary classes! Check log for details!"), level=QgsMessageBar.CRITICAL)
else:
self.loadLayers()
QApplication.restoreOverrideCursor()
self.close()
def loadLayers(self):
"""
Loads the layers defined in the line-centroid structure
"""
try:
if self.widget.abstractDb.getDatabaseVersion() == 'Non_EDGV':
isEdgv = False
else:
isEdgv = True
auxClassesDict = self.widgetConv.settingDict['earthCoverageDict']
auxClasses = []
for key in list(auxClassesDict.keys()):
for cl in auxClassesDict[key]:
if cl not in auxClasses:
if '.' in cl:
classToLoad = cl.split('.')[-1]
else:
classToLoad = cl
auxClasses.append(classToLoad)
auxCentroids = self.widgetConv.abstractDb.getEarthCoverageCentroids()
auxClasses = auxClasses + auxCentroids
auxClasses.sort(reverse=True)
auxClasses = [self.widgetConv.settingDict['frameLayer'].split('.')[-1]]+auxClasses
factory = self.layerFactory.makeLoader(self.iface, self.widget.abstractDb, loadCentroids=True)
factory.load(auxClasses, uniqueLoad = True, isEdgv = isEdgv)
except Exception as e:
QgsMessageLog.logMessage(':'.join(e.args), "DSGTools Plugin", Qgis.Critical)
self.bar.pushMessage(self.tr("Error!"), self.tr("Could not load auxiliary classes! Check log for details!"), level=QgsMessageBar.CRITICAL)