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',
'KKGPlugin_{}.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)
# Create the dialog (after translation) and keep reference
# TODO für unittest auskommentiert
self.dlg = KKGPluginDialog()
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&kkgplugin')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'KKGPlugin')
self.toolbar.setObjectName(u'KKGPlugin')
# Referenz für Interaktion zwischen Handler und QGIS
Handler.QGIS = self
# Start server
self.server = Server(10000)
self.server.start()
class KKGPlugin:
"""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',
'KKGPlugin_{}.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)
# Create the dialog (after translation) and keep reference
# TODO für unittest auskommentiert
self.dlg = KKGPluginDialog()
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&kkgplugin')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'KKGPlugin')
self.toolbar.setObjectName(u'KKGPlugin')
# Referenz für Interaktion zwischen Handler und QGIS
Handler.QGIS = self
# Start server
self.server = Server(10000)
self.server.start()
# 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('KKGPlugin', 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
"""
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."""
icon_path = ':/plugins/KKGPlugin/img/ic_settings_black_24px.svg'
self.add_action(
icon_path,
text=self.tr(u'Layereinstellungen'),
callback=self.run,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/KKGPlugin/img/ic_email_black_24px.svg'
self.add_action(
icon_path,
text=self.tr(u'Fläche an KKG senden'),
callback=self.send_area,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/KKGPlugin/img/ic_playlist_add_black_24px.svg'
self.add_action(
icon_path,
text=self.tr(u'Tabellenspalten einfügen'),
callback=self.add_table_columns,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/KKGPlugin/img/ic_call_made_black_24px.svg'
self.add_action(
icon_path,
text=self.tr(u'Exportieren'),
callback=self.export_features,
parent=self.iface.mainWindow()
)
icon_path = ':/plugins/KKGPlugin/img/ic_info_black_24px.svg'
self.add_action(
icon_path,
text=self.tr(u'Eigentümerinformationen'),
callback=self.get_owner_info,
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'&kkgplugin'),
action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
# Server beenden
self.server.stop()
self.server.join()
QgsMessageLog.logMessage("joined", "KKG Plugin Debug", QgsMessageLog.INFO)
def set_selected_features(self, features):
"""
wählt die aus der XML von KKG gesendeten Flurstücke in QGIS aus
:param features: Dictionary der auszuwählenden Features
:type: dictionary
:return:
"""
# Layer soll erzwungen werden
cond1 = self.dlg.forceCheckBox.isChecked()
# keine Informationen zum Layer in Daten vorhanden
cond2 = features['column'] is None or features['layer'] is None
# Daten aus UI verwenden
if cond1 or cond2:
layer = self.dlg.layerCombo.currentText()
col = self.dlg.keyCombo.currentText()
# Daten aus XML verwenden
else:
col = features['column']
layer = features['layer']
assert col is not None and layer is not None
if col is None or layer is None:
# TODO raise message
pass
# Auswahlstring für QGIS
filter_expression = u'"{field}" = \'{value}\''
selection_string = ''.join(filter_expression.format(field=col, value=elem) + " OR " for elem in
features['elems'])
# Abschließendes " OR " entfernen
selection_string = selection_string[:-4]
QgsMessageLog.logMessage(selection_string, "KKG Plugin Debug", QgsMessageLog.INFO)
layers = QgsMapLayerRegistry.instance().mapLayersByName(layer)
selection_layer = layers[0]
selected_elements = selection_layer.getFeatures(QgsFeatureRequest().setFilterExpression(selection_string))
# Falls Auswahl besteht -> Aufheben
selection = []
for elem in selected_elements:
selection.append(int(elem.id()))
try:
# QgsMessageLog.logMessage(selection, "KKG Plugin Debug", QgsMessageLog.INFO)
selection_layer.setSelectedFeatures([])
selection_layer.setSelectedFeatures(selection)
self.iface.setActiveLayer(selection_layer)
selection_layer.triggerRepaint()
except Exception as e:
# TODO logging
pass
return self.iface.activeLayer().selectedFeatures()
def send_area(self, sending="sending"):
"""
Sendet die aus der ausgewählten Geometrie ermittelten Fläche an KKG
:return:
"""
# Fehlermeldung, falls kein Layer oder kein Feature ausgewählt ist.
active_layer = self.iface.activeLayer()
if active_layer is None:
self.raise_message("no_active_layer")
return
elif active_layer.selectedFeatureCount() == 0:
self.raise_message("no_features_selected")
return
else:
selected_features = active_layer.selectedFeatures()
xml = self._create_xml_to_send(selected_features)
# None, wenn XML-Generierung fehlschlägt
if xml is not None:
self.server.send(config.host, config.out_port, xml)
return True
else:
return False
def _create_xml_to_send(self, selected_features):
"""
:param selected_features:
:return:
:rtype: String
"""
event = ElementTree.Element('event', attrib={'xmlns': 'http://gvsigce/ExternalComm'})
ElementTree.SubElement(event, 'name', attrib={'name': 'KKG-Ereignis', 'version': '1.0.0'})
actions = ElementTree.SubElement(event, 'actions')
for feature in selected_features:
try:
area = ElementTree.SubElement(actions, 'area', attrib={'value': str(feature.geometry().area())})
fltr = ElementTree.SubElement(area, 'filter')
equals = ElementTree.SubElement(fltr, 'property')
prop = ElementTree.SubElement(equals, 'property')
# Spaltennamen übergeben?
if self.dlg.keyCombo.currentText() == "":
self.raise_message("no_column_defined")
return
else:
prop.text = self.dlg.keyCombo.currentText()
string = ElementTree.SubElement(equals, 'string')
string.text = feature.attribute(self.dlg.keyCombo.currentText())
except KeyError as e:
QgsMessageLog.logMessage("Fehler bei XML-Erzeugung: " + e.message, "KKG Plugin", QgsMessageLog.WARNING)
return
# File vortäuschen, da andernfalls die XML-Declaration nicht erzeugt wird
fake_file = BytesIO()
doc = ElementTree.ElementTree(event)
doc.write(fake_file, encoding='utf-8', xml_declaration=True)
return fake_file.getvalue()
def add_table_columns(self):
"""
Fügt die benötigten Tabellenfelder in die Attributtabelle ein
:return:
"""
layer = self.iface.activeLayer()
QgsMessageLog.logMessage(u"Tabellenfelder werden für " + unicode(layer.name()) + u" erzeugt.")
if layer is None:
self.raise_message("no_active_layer")
return
else:
capabilities = layer.dataProvider().capabilities
field_names = ["geschosse", "gewerbe", "ecke", "lfd. nr."]
for field in layer.pendingFields():
if field.name().lower() in field_names:
reply = self.raise_message("fields_already_existing")
# Überschreiben?
if reply == QMessageBox.Yes:
if capabilities and QgsVectorDataProvider.DeleteAttributes:
data_provider = layer.dataProvider()
field_names = data_provider.fieldNameMap()
try:
data_provider.deleteAttributes([
field_names['geschosse'],
field_names['gewerbe'],
field_names['ecke'],
field_names['lfd. nr.'],
field_names['flaeche'],
field_names['flsnr']
])
except KeyError:
pass
break
else:
return
layer.dataProvider().addAttributes([
QgsField("geschosse", QVariant.Int),
QgsField("gewerbe", QVariant.Int),
QgsField("ecke", QVariant.Int),
QgsField("lfd. nr.", QVariant.String),
QgsField("flaeche", QVariant.Double),
QgsField("flsnr", QVariant.String)
])
# Geschosse initial mit 0 belegen
layer.startEditing()
field_id = layer.dataProvider().fieldNameMap()[u'geschosse']
field_id2 = layer.dataProvider().fieldNameMap()[u'flsnr']
iterator = layer.getFeatures()
for feature in iterator:
layer.changeAttributeValue(feature.id(), field_id, 0)
gml_id = feature.attribute('gml_id')
fsn = self._get_fsn_from_gml_id(gml_id)[0]['flsnr']
layer.changeAttributeValue(feature.id(), field_id2, fsn)
layer.commitChanges()
layer.updateFields()
self.raise_message("columns_added")
QgsMessageLog.logMessage("Tabellenfelder erfolgreich erzeugt", "KKG Plugin", QgsMessageLog.INFO)
def move_line(self):
raise NotImplementedError
def export_features(self):
"""
Exportiert die Datenbanklayer als ESRI-Shapefile
:return:
"""
directory = QFileDialog.getExistingDirectory()
if not directory:
return
# Abfrage, ob Daten überschrieben werden sollen, wenn Verzeichnis nicht leer
override = True
if os.listdir(directory):
reply = self.raise_message("dir_not_empty")
if reply == QMessageBox.Yes:
pass
else:
override = False
# Verzeichnis leer oder override = True
if override:
# progress bar
QgsMessageLog.logMessage("Exportiere nach " + directory, "KKG Plugin", QgsMessageLog.INFO)
layers = QgsMapLayerRegistry.instance().mapLayers().values()
progress_message_bar = self.iface.messageBar().createMessage("Exportiere...")
progress = QProgressBar()
progress.setMaximum(len(layers))
progress.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
progress_message_bar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progress_message_bar, self.iface.messageBar().INFO)
# current extent
extent = self.iface.mapCanvas().extent()
for i in range(0, len(layers)):
layer = layers[i]
file_path = directory + "\\" + layer.name()
errors = QgsVectorFileWriter.writeAsVectorFormat(layer,
file_path,
"UTF-8",
None,
"ESRI Shapefile",
filterExtent=extent,
symbologyExport=QgsVectorFileWriter.NoSymbology)
if errors:
QgsMessageLog.logMessage(layer.name() + " konnte nicht geschrieben werden.", "KKG Plugin",
QgsMessageLog.WARNING)
else:
QgsMessageLog.logMessage(layer.name() + " erfolgreich geschrieben", "KKG Plugin",
QgsMessageLog.INFO)
progress.setValue(i + 1)
self.iface.messageBar().clearWidgets()
QgsMessageLog.logMessage("Export abgeschlossen", "KKG Plugin", QgsMessageLog.INFO)
self._create_project_from_export(directory)
def _create_project_from_export(self, directory):
"""
Erzeugt eine .qgs-Projektdatei aus den im Verzeichnis enthaltenen Shapefiles, weist die zugehörigen Legenden
zu und ruft das erzeugte Projekt in einer neuen QGIS-Instanz auf.
:param directory: Verzeichnis, in dem das Projekt erzeugt werden soll und welches die Shapefiles für das
Projekt enthält
:return:
"""
QgsMessageLog.logMessage("Erstelle Projektdatei...", "KKG Plugin", QgsMessageLog.INFO)
project_name = os.path.basename(os.path.normpath(directory))
project_file_name = os.path.basename(os.path.normpath(directory)) + ".qgs"
directory += "\\"
if os.path.isfile(os.path.normpath(directory + project_file_name)):
os.remove(directory + project_file_name)
project = QgsProject.instance()
project.clear()
QgsMapLayerRegistry.instance().removeAllMapLayers()
root = QgsProject.instance().layerTreeRoot()
alkis = root.addGroup("ALKIS")
flurstuecke = alkis.addGroup(u"Flurstücke")
flaechen_flur = flurstuecke.addGroup(u"Flächen")
layer1 = QgsVectorLayer(directory + u"Linien (Flurstücke).shp", u"Linien (Flurstücke)", "ogr")
layer2 = QgsVectorLayer(directory + u"Grenzen (Flurstücke).shp", u"Grenzen (Flurstücke)", "ogr")
layer1.loadNamedStyle(config.legend_basepath + u"Linien (Flurstücke)_flaechen.qml")
layer2.loadNamedStyle(config.legend_basepath + u"Grenzen (Flurstücke).qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
QgsMapLayerRegistry.instance().addMapLayer(layer2, False)
flaechen_flur.addLayer(layer1)
flaechen_flur.addLayer(layer2)
nummern_flur = flurstuecke.addGroup("Nummern")
layer1 = QgsVectorLayer(directory + u"Beschriftungen (Flurstücke).shp", u"Beschriftungen (Flurstücke)", "ogr")
layer2 = QgsVectorLayer(directory + u"Linien (Flurstücke).shp", u"Linien (Flustücke)", "ogr")
layer1.loadNamedStyle(config.legend_basepath + u"Beschriftungen (Flurstücke).qml")
layer2.loadNamedStyle(config.legend_basepath + u"Linien (Flurstücke)_nummern.qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
QgsMapLayerRegistry.instance().addMapLayer(layer2, False)
nummern_flur.addLayer(layer1)
nummern_flur.addLayer(layer2)
gebaeude = alkis.addGroup(u"Gebäude")
gebaeude_gebaeude = gebaeude.addGroup(u"Gebäude")
layer1 = QgsVectorLayer(directory + u"Beschriftungen (Gebäude).shp", u"Beschriftungen (Gebäude)", "ogr")
layer2 = QgsVectorLayer(directory + u"Punkte (Gebäude).shp", u"Punkte (Gebäude)", "ogr")
layer3 = QgsVectorLayer(directory + u"Flächen (Gebäude).shp", u"Flächen (Gebäude).shp", "ogr")
layer1.loadNamedStyle(config.legend_basepath + u"Beschriftungen (Gebäude).qml")
layer2.loadNamedStyle(config.legend_basepath + u"Punkte (Gebäude).qml")
layer3.loadNamedStyle(config.legend_basepath + u"Flächen (Gebäude).qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
QgsMapLayerRegistry.instance().addMapLayer(layer2, False)
QgsMapLayerRegistry.instance().addMapLayer(layer3, False)
gebaeude_gebaeude.addLayer(layer1)
gebaeude_gebaeude.addLayer(layer2)
gebaeude_gebaeude.addLayer(layer3)
nr_gebaeude = gebaeude.addGroup("Laufende Hausnummern")
layer1 = QgsVectorLayer(directory + u"Beschriftungen (Gebäude).shp", u"Beschriftungen (Gebäude)", "ogr")
layer1.loadNamedStyle(config.legend_basepath + u"Beschriftungen (Gebäude).qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
nr_gebaeude.addLayer(layer1)
lagebezeichnung = alkis.addGroup("Lagebezeichnungen")
beschr_lagebez = lagebezeichnung.addGroup("Beschriftungen")
layer1 = QgsVectorLayer(directory + "Beschriftungen (Lagebezeichnungen).shp",
"Beschriftungen (Lagebezeichnungen)",
"ogr")
layer1.loadNamedStyle(config.legend_basepath + "Beschriftungen (Lagebezeichnungen).qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
beschr_lagebez.addLayer(layer1)
verkehr = alkis.addGroup("Verkehr")
layer1 = QgsVectorLayer(directory + u"Flächen (Verkehr).shp", u"Flächen (Verkehr)", "ogr")
layer1.loadNamedStyle(config.legend_basepath + u"Flächen (Verkehr).qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
verkehr.addLayer(layer1)
pol_grenzen = alkis.addGroup("Politische Grenzen")
layer1 = QgsVectorLayer(directory + "Linien (Politische Grenzen).shp", "Linien (Politische Grenzen)", "ogr")
layer1.loadNamedStyle(config.legend_basepath + "Linien (Politische Grenzen).qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
pol_grenzen.addLayer(layer1)
industrie = alkis.addGroup("Industrie und Gewerbe")
layer1 = QgsVectorLayer(directory + u"Flächen (Industrie und Gewerbe).shp",
u"Flächen (Industrie und Gewerbe)",
"ogr")
layer1.loadNamedStyle(config.legend_basepath + u"Flächen (Industrie und Gewerbe).qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
industrie.addLayer(layer1)
sport_freizeit = alkis.addGroup("Sport und Freizeit")
layer1 = QgsVectorLayer("Punkte (Sport und Freizeit).shp", "Punkte (Sport und Freizeit)", "ogr")
layer1.loadNamedStyle(config.legend_basepath + "Punkte (Sport und Freizeit).qml")
QgsMapLayerRegistry.instance().addMapLayer(layer1, False)
sport_freizeit.addLayer(layer1)
project.setTitle(project_name)
project.setFileName(directory + project_file_name)
if project.write():
QgsMessageLog.logMessage("Projektdatei " + directory + project_file_name + " wurde erfolgreich "
"geschrieben.", "KKG Plugin",
QgsMessageLog.INFO)
self.iface.messageBar().pushSuccess("Erfolgreich", "Der Inhalt wurde erfolgreich exportiert.")
if self.raise_message("ask_if_project_start") == QMessageBox.Yes:
self.iface.mapCanvas().clear()
QgsMapLayerRegistry.instance().removeAllMapLayers()
project.read(QFileInfo(directory + project_file_name))
print project_name
self.iface.mainWindow().setWindowTitle(project_name)
QgsMessageLog.logMessage("Exportiertes Projekt wird gestartet", "KKG Plugin", QgsMessageLog.INFO)
QgsMessageLog.logMessage("Export abgeschlossen, lokales Projekt geladen", "KKG Plugin", QgsMessageLog.INFO)
else:
QgsMessageLog.logMessage("Exportiertes Projekt wird nicht gestartet", "KKG Plugin", QgsMessageLog.INFO)
def get_owner_info(self):
"""
Fragt die Eigentümerinformationen aus der ALKIS-Datenbank ab und stellt sie im Stil des NorBIT-Plugins dar.
:return:
"""
self.map_tool = QgsMapToolEmitPoint(self.iface.mapCanvas())
self.iface.mapCanvas().setMapTool(self.map_tool)
self.map_tool.canvasClicked.connect(self._clicked)
def _clicked(self, point, button):
if self.iface.activeLayer() is None:
self.raise_message("no_active_layer")
return
# Prüfe, ob Punkt innerhalb des Features
for feature in self.iface.activeLayer().getFeatures():
#Falls Punkt in Features
if feature.geometry().contains(point):
#hole gml_id
try:
gml_id = feature.attribute('gml_id')
except KeyError:
self.raise_message("no_gml_id_found")
return
break
# ids = tuple(str(feature.attribute('gml_id')) for feature in selected_features)
result = self._get_fsn_from_gml_id(gml_id)
html = self._build_html(result[0]['flsnr'])
parent = QDialog()
parent.setWindowTitle(u"Eigentümerinformationen")
parent.setParent(self.iface.mainWindow())
parent.setWindowFlags(QtCore.Qt.Window)
textview = QTextEdit()
textview.setReadOnly(True)
textview.setText(html)
layout = QGridLayout(parent)
layout.addWidget(textview)
parent.resize(500, 600)
parent.show()
def _get_fsn_from_gml_id(self, feature_list):
"""
Ruft die Eigentümerinformaionen anhand der gml_id der Flurstücke aus der ALKIS-DB ab.
:param features: Liste der Features, deren Eigentümerinformationen abgerufen werden sollen
:type list
:return: Eigentümerinformationen
:rtype list
"""
db = Alkis()
query = """
SELECT *
FROM
(SELECT
gml_id,
(land ||
gemarkungsnummer ||
'-' ||
trim(to_char(flurnummer, '000')) ||
'-' || trim(to_char(zaehler, '00000')) ||
'/000') AS flsnr
FROM ax_flurstueck) flur
WHERE flur.gml_id = %s
"""
return db.query(query, (feature_list,))
def _build_html(self, fs):
"""
Weitestgehend aus dem ALKIS-Plugin der Firma norBIT übernommen und auf die eigene Datenbankverbindung
umgeschriebene Methode zum Abruf der Flurstücksinformationen, wenn die Daten aus der Datenbank ausgespielt
worden sind.
Credits to jef-n (https://github.com/jef-n)
:param fs: Flurstücksnummer des betroffenen Flurstücks
:type String
:return: HTML-Repräsentation der Flurstücksinformationen
:rtype String
"""
fs = fs.rstrip(' ')
db = Alkis()
res = db.query("SELECT 1 FROM pg_attribute WHERE attrelid=(SELECT oid FROM pg_class WHERE "
"relname='eignerart') AND attname='anteil'", None)
if res:
exists_ea_anteil = (res[0]['?column?'] == 1)
else:
exists_ea_anteil = False
html = ""
qry = """
SELECT
ea.bvnr,
'' as pz,
(SELECT eignerart FROM eign_shl WHERE ea.b=b) as eignerart,
%s as anteil,
ea.ff_stand AS zhist,
b.bestdnr,
b.gbbz,
b.gbblnr,
b.bestfl,
b.ff_stand AS bhist
FROM eignerart ea
JOIN bestand b ON ea.bestdnr = b.bestdnr
WHERE ea.flsnr = '%s'
ORDER BY zhist,bhist,b""" % ("ea.anteil" if exists_ea_anteil else "''", fs)
best = db.query(qry, None)
res = db.query(
"SELECT f.*,g.gemarkung FROM flurst f LEFT OUTER JOIN gema_shl g ON (f.gemashl=g.gemashl) WHERE "
"f.flsnr='%s' AND f.ff_stand=0" % fs, None)
if len(res) == 1:
res = res[0]
else:
QMessageBox.information(None, "Fehler", u"Flurstück %s nicht gefunden.\n[%s]" % (fs, repr(fs)))
return
res['datum'] = QDate.currentDate().toString("d. MMMM yyyy")
res['hist'] = 0
res['str'] = db.query(
"SELECT sstr.strname,str.hausnr FROM str_shl sstr JOIN strassen str ON "
"str.strshl=sstr.strshl WHERE str.flsnr='%s' AND str.ff_stand=0" % fs, None)
res['nutz'] = db.query(
"SELECT n21.*, nu.nutzshl, nu.nutzung FROM nutz_21 n21, nutz_shl nu WHERE "
"n21.flsnr='%s' AND n21.nutzsl=nu.nutzshl AND n21.ff_stand=0" % fs, None)
res['klas'] = db.query(
"SELECT kl.*, kls.klf_text FROM klas_3x kl, kls_shl kls WHERE kl.flsnr='%s' AND "
"kl.klf=kls.klf AND kl.ff_stand=0" % fs, None)
res['afst'] = db.query(
"SELECT au.*, af.afst_txt FROM ausfst au,afst_shl af WHERE au.flsnr='%s' AND "
"au.ausf_st=af.ausf_st AND au.ff_stand=0" % fs, None)
res['best'] = db.query(
"SELECT ea.bvnr,'' as pz,(SELECT eignerart FROM eign_shl WHERE ea.b = b) as eignerart,%s as anteil,ea.ff_stand AS zhist,b.bestdnr,b.gbbz,b.gbblnr,b.bestfl,b.ff_stand AS bhist FROM eignerart ea JOIN bestand b ON ea.bestdnr = b.bestdnr WHERE ea.flsnr='%s' ORDER BY zhist,bhist,b" %
("ea.anteil" if exists_ea_anteil else "''", fs), None)
for b in res['best']:
b['bse'] = db.query("SELECT * FROM eigner WHERE bestdnr='%s' AND ff_stand=0" % b['bestdnr'], None)
html = u"""
<HTML xmlns="http://www.w3.org/1999/xhtml">
<HEAD>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</HEAD>
<BODY>
<style>
.fls_tab{width:100%%;empty-cells:show}
.fls_time{text-align:right;width:100%%}
.fls_headline_col{background-color:#EEEEEE;width:100%%;height:30px;text-align:center;}
.fls_headline{font-weight:bold;font-size:24px;}
.fls_col_names{font-weight:bold;}
.fls_col_values{vertical-align:top;}
.fls_bst{width:100%%;empty-cells:show}
.fls_hr{border:dotted 1px;color:#080808;}
</style>
<TABLE class="fls_tab" border="0">
<TR><TD>Flurstücksnachweis</TD><TD class="fls_time" colspan="6"><span>%(datum)s</TD></TR>
<TR><TD colspan="7"><hr style="width:100%%"></TD></TR>
<TR class="fls_headline_col">
<TD colspan="7"><span class="fls_headline">Flurstücksnachweis<span></TD>
</TR>
<TR><TD colspan="7"> </TD></TR>
<TR>
<TD colspan="7"><h3>Flurstück<hr style="width:100%%"></h3></TD>
</TR>
<TR class="fls_col_names">
<TD width="15%%">Gemarkung</TD>
<TD width="6%%">Flur</TD>
<TD width="15%%">Flurstück</TD>
<TD width="20%%">Flurkarte</TD>
<TD width="17%%">Entstehung</TD>
<TD width="17%%">Fortführung</TD>
<TD width="5%%">Fläche</TD>
</TR>
<TR class="fls_col_values">
<TD>%(gemashl)s<br>%(gemarkung)s</TD>
<TD>%(flr)s</TD>
<TD>%(flsnrk)s</TD>
<TD>%(flurknr)s</TD>
<TD>%(entst)s</TD>
<TD>%(fortf)s</TD>
<TD nowrap>%(flsfl)s m²</TD>
</TR>
</TABLE>
""" % res
if res['blbnr']:
html += """
<TABLE border="0" class="fls_tab">
<TR class="fls_col_names">
<TD width="21%%"></TD>
<TD width="79%%">Baulastenblattnr.</TD>
</TR>
<TR class="fls_col_values">
<TD></TD>
<TD>%(blbnr)s</TD>
</TR>
</TABLE>
""" % res
if res['lagebez'] or res['anl_verm']:
html += """
<TABLE border="0" class="fls_tab">
<TR class="fls_col_names">
<TD width="21%%"></TD>
<TD width="52%%">Lage</TD>
<TD width="27%%">Anliegervermerk</TD>
</TR>
<TR class="fls_col_values">
<TD></TD>
<TD>%(lagebez)s</TD>
<TD>%(anl_verm)s</TD>
</TR>
</TABLE>
""" % res
if res['str']:
html += """
<TABLE border="0" class="fls_tab">
<TR class="fls_col_names">
<TD></TD><TD>Strasse</TD><TD>Hausnummer</TD>
</TR>
"""
for strres in res['str']:
html += """
<TR class="fls_col_values">
<TD></TD><TD>%(strname)s</TD><TD>%(hausnr)s</TD></TR>
</TR>
""" % strres
html += """
</TABLE>
"""
if res['nutz']:
html += """
<TABLE border="0" class="fls_tab">
<TR class="fls_col_names"><TD width="21%%"></TD><TD width="69%%">Nutzung</TD><TD width="10%%">Fläche</TD></TR>
"""
for nutz in res['nutz']:
html += """
<TR class="fls_col_values"><TD></TD><TD>21%(nutzshl)s - %(nutzung)s</TD><TD nowrap>%(fl)s m²</TD></TR>
""" % nutz
html += """
</TABLE>
"""
else:
html += """
<p>Keine Nutzungen.</p>
"""
if res['klas']:
html += """
<TABLE border="0" class="fls_tab">
<TR class="fls_col_names"><TD width="21%%"></TD><TD width="69%%">Klassifizierung</TD><TD width="10%%">Fläche</TD></TR>
"""
for klas in res['klas']:
html += """
<TR class="fls_col_values"><TD></TD><TD>%(klf_text)s</TD><TD nowrap>%(fl)s m²</TD></TR>
""" % klas
html += """
</TABLE>
"""
else:
html += """
<p>Keine Klassifizierungen.</p>
"""
if res['afst']:
html += """
<TABLE border="0" class="fls_tab">
<TR class="fls_col_names"><TD width="21%%"></TD><TD width="79%%">Ausführende Stelle</TD></TR>
"""
for afst in res['afst']:
html += """
<TR class="fls_col_values"><TD></TD><TD>%(afst_txt)s</TD></TR>
""" % afst
html += """
</TABLE>
"""
else:
html += """
<p>Keine ausführenden Stellen.</p>
"""
if res['best']:
html += """
<TABLE border="0" class="fls_bst">
<TR><TD colspan="6"><h3>Bestände<hr style="width:100%%"></h3></TD></TR>
"""
for best in res['best']:
html += """
<TR class="fls_col_names">
<TD>Bestandsnummer</TD>
<TD>Grundbuchbezirk</TD>
<TD colspan="2">Grundbuchblattnr.</TD>
<TD>Anteil</TD>
</TR>
<TR class="fls_col_values">
<TD>%(bestdnr)s</TD>
<TD>%(gbbz)s</TD>
<TD colspan="2">%(gbblnr)s</TD>
<TD>%(anteil)s</TD>
</TR>
<TR class="fls_col_names">
<TD></TD>
<TD>Buchungskennz.</TD>
<TD>BVNR</TD>
<TD>PZ</TD>
""" % best
if res['hist']:
html += """
<TD>Hist. Bestand</TD><TD>Hist. Zuordnung</TD>
"""
else:
html += """
<TD></TD><TD></TD>
"""
html += """
</TR>
<TR class="fls_col_values">
<TD></TD>
<TD>%(eignerart)s</TD>
<TD>%(bvnr)s</TD>
<TD>%(pz)s</TD>
""" % best
html += "<TD>%s</TD>" % ("ja" if res['hist'] and best['bhist'] else "")
html += "<TD>%s</TD>" % ("ja" if res['hist'] and best['zhist'] else "")
html += """
</TR>
"""
if best['bse']:
html += """
<TR class="fls_col_names"><TD>Anteil</TD><TD colspan="5">Namensinformation</TD></TR>
"""
for bse in best['bse']:
html += """
<TR class="fls_col_values">
<TD>%(antverh)s</TD>
<TD colspan="5">%(name1)s %(name2)s<br>%(name3)s<br>%(name4)s</TD>
</TR>
""" % bse
else:
html += """
<p>Keine Eigner gefunden.</p>
"""
html += """
<TR><TD colspan="6"><hr class="fls_hr"></TD></TR>
"""
html += """
</TABLE>
</BODY>
</HTML>
"""
return html
def raise_message(self, string):
"""
Sammelmethode für die Ausgabe von MessageBoxes
:param string: Identifier welche Information auszugeben ist
:type string: String
"""
if string == "no_listener_registered":
text = u'Es wurde ein Event empfangen, es ist jedoch kein Layer registriert. '
u'Bitte wählen Sie einen Layer und eine Schlüsselspalte in den '
u'Layereinstellungen (Zahnradsymbol) aus.'
self.iface.messageBar().pushMessage("Achtung", text, level=QgsMessageBar.WARNING, duration=10)
elif string == "layer_registered":
text = u'Der Listener wurde erfolgreich auf die Spalte "%s" im Layer "%s" registiert.' % (
self.dlg.keyCombo.currentText(), self.dlg.layerCombo.currentText())
self.iface.messageBar().pushMessage("Info", text, level=QgsMessageBar.INFO, duration=5)
elif string == "columns_added":
text = u'Die Spalten wurden der Tabelle erfolgreich hinzugefügt.'
self.iface.messageBar().pushMessage("Info", text, level=QgsMessageBar.INFO, duration=5)
elif string == "no_side":
text = u'Bitte wählen Sie eine Seite aus.'
self.iface.messageBar().pushMesssage("Fehler", text, level=QgsMessageBar.WARNING, duration=10)
elif string == "fields_already_existing":
return \
QMessageBox.question(
self.iface.mainWindow(),
u"Felder bereits vorhanden",
u"Eines oder mehrere Felder sind bereits vorhanden oder wurden\n"
u"bereits hinzugefügt. Sollen die Felder trotzdem hinzugefügt werden?\n"
u"VORSICHT: Vorhandene Daten werden dabei überschrieben!",
QMessageBox.Yes,
QMessageBox.No
)
elif string == "no_column_defined":
QMessageBox.warning(
self.iface.mainWindow(),
u'Fehler',
u'Es wurde keine Schlüsselspalte ausgewählt. Bitte wählen Sie einen Layer und eine\n'
u'Schlüsselspalte in den Layereinstellungen (Zahnradsymbol) aus.'
)
elif string == "no_active_layer":
text = u'Es ist kein Layer ausgewählt.'
self.iface.messageBar().pushMessage("Fehler", text, level=QgsMessageBar.WARNING, duration=10)
elif string == "no_features_selected":
text = u'Es können keine Daten gesendet werden, da keine Features ausgewählt sind.'
self.iface.messageBar().pushMessage("Fehler", text, level=QgsMessageBar.WARNING, duration=10)
elif string == "no_gml_id_found":
text = u'Die Abfrage der Eigentümerdaten ist fehlgeschlagen, da das benötigte Tabellenfeld nicht gefunden wurde'
self.iface.messageBar().pushMessage("Fehler", text, level=QgsMessageBar.WARNING, duration=10)
elif string == "mem_layer_not_supported":
QMessageBox.information(
self.iface.mainWindow(),
u'Memorylayer nicht unterstützt!',
u'Der verwendete Layer ist ein temporärer Layer, mit\n'
u'dem die gewünschte Operation nicht möglich ist.\n'
u'Speichern Sie den Layer als Shapefile (Rechtsklick -> Speichern als...)\n'
u'und starten Sie den Vorgang erneut'
)
elif string == "dir_not_empty":
return QMessageBox.question(
self.iface.mainWindow(),
u"Verzeichnis nicht leer",
u"Das angegebene Verzeichnis ist nicht leer. Es werden möglicherweise Daten überschrieben,"
u"was zu Datenverlust führen kann. Möchten Sie dennoch in das angegebene Verzeichnis schreiben?",
QMessageBox.Yes,
QMessageBox.No
)
elif string == "ask_if_project_start":
return QMessageBox.question(
self.iface.mainWindow(),
u"Projekt öffnen?",
u"Soll das exportierte Projekt geöffnet werden?",
QMessageBox.Yes,
QMessageBox.No
)
else:
text = u'Es ist ein Fehler aufgetreten'
self.iface.messageBar().pushMessage("Fehler", text, level=QgsMessageBar.CRITICAL, duration=10)
# noinspection PyPep8Naming
@QtCore.pyqtSlot(str)
def onLayerSelectionChange(self, index):
"""
Fügt die im Shapefile vorhandenen Spaltennamen in die QComboBox für die Auswahl der Schlüsselspalte ein.
:param index: Index des ausgewählten Objekts
:type index: Integer
"""
# Wenn Combobox bei Layerauswahl geleert wird: Event verwerfen
if index == -1:
return
self.dlg.keyCombo.clear()
layer = self.dlg.layerCombo.itemData(index)
# Tabellen-Header
cols = layer.pendingFields()
# länge ermitteln
combo_size = self.dlg.keyCombo.count()
# ComboBox leeren
for i in range(0, combo_size):
self.dlg.keyCombo.removeItem(i)
# Spaltennamen in Header einfügen
for col in cols:
self.dlg.keyCombo.addItem(col.name(), layer)
def run(self):
"""Run method that performs all the real work"""
# Layerliste leeren
self.dlg.layerCombo.clear()
# Layer im Projekt
layers = QgsMapLayerRegistry.instance().mapLayers().values()
# Layer in Dropdown-Liste schreiben
for l in layers:
if l.type() == QgsMapLayer.VectorLayer:
self.dlg.layerCombo.addItem(l.name(), l)
# keyCombo erstmalig mit erstem Layer belegen, falls vorhanden
index = self.dlg.layerCombo.currentIndex()
first_layer = self.dlg.layerCombo.itemData(index)
if first_layer is not None:
for column in first_layer.pendingFields():
self.dlg.keyCombo.addItem(column.name(), first_layer)
# Signal registrieren, wenn sich die Layerauswahl ändert
self.dlg.layerCombo.currentIndexChanged[int].connect(self.onLayerSelectionChange)
# Falls aktiver Layer vorhanden, setze als Standard
active_layer = self.iface.activeLayer()
if active_layer is not None:
active_layer_index = self.dlg.layerCombo.findText(active_layer.name())
self.dlg.layerCombo.setCurrentIndex(active_layer_index)
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
self.raise_message("layer_registered")