def processAlgorithm(self, progress):
"""Here is where the processing itself takes place."""
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setPercentage(50)
plantinput = self.getParameterValue(self.PLANTIDORNAME)
onlypublic_watersupply = self.getParameterValue(
self.ONLYPUBLICWATERSUPPLY)
output = self.getOutputFromName(self.OUTPUT)
JupiterAux.log_info(u'\nprocessAlgorithm: {}'.format(self.tablename))
pgtablename = u'mstmvw_catchperm'
ok_add_map = True
if ok_add_map:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setPercentage(100)
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(
u'<br><b>Tabel {} er åbnet med navnet {}</b>'.format(
self.tablename, self.PLANTIDORNAME))
else:
progress.setInfo(u'Der er sket en fejl i "{}"'.format(self.name))
progress.setPercentage(100)
def writeOutputVector(self, progress, pglayer, output, isSpatial=True):
"""Write output
:param pglayer: quried pg layer qgsvectorlayer to be written
:param output: output processing object
:param isSpatial: non spatial loads explictly
:return: True if no error
"""
JupiterAux.log_info('writing output vector: {}'.format(output.value))
#error = QgsVectorFileWriter.writeAsVectorFormat(vlayer, outputfile, "utf-8", None, "ESRI Shapefile")
#error = QgsVectorFileWriter.writeAsVectorFormat(vlayer, outputfile, "utf-8", None)
output_writer = output.getVectorWriter(pglayer.fields(),
pglayer.wkbType(),
pglayer.crs())
outFeat = QgsFeature()
features = vector.features(pglayer)
total = 100.0 / len(features) if len(features) > 0 else 1
for current, feat in enumerate(features):
progress.setPercentage(int(current * total))
if isSpatial:
geom = feat.geometry()
outFeat.setGeometry(geom)
atMap = feat.attributes()
atMap.append(None)
outFeat.setAttributes(atMap)
output_writer.addFeature(outFeat)
del output_writer
return True
def showFeatureCount(self, layername, show=True):
"""Set the feature count. TODO not working ...
:param layername: layer to set style for
:param show: toggle visibility
:return: True if no error
"""
root = QgsProject.instance().layerTreeRoot()
for child in root.children():
if isinstance(child, QgsLayerTreeLayer):
JupiterAux.log_info('----- {}'.format(child.layerName()))
if child.layerName() == layername:
child.setCustomProperty("showFeatureCount", show)
def processAlgorithm(self, progress):
JupiterAux.log_info(u'\nprocessAlgorithm: {}'.format(self.tablename))
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setPercentage(30)
extent = self.getParameterValue(self.EXTENT)
extent_layer = self.getParameterValue(self.VECTOR_SELECTION)
compoundname1 = unicode(self.getParameterValue(self.COMPOUNDNAME1))
compoundname2 = unicode(self.getParameterValue(self.COMPOUNDNAME2))
xaxeline = self.getParameterValue(self.XAXELINE)
yaxeline = self.getParameterValue(self.YAXELINE)
showannotations = self.getParameterValue(self.SHOWANNOTATIONS)
date_from = self.getParameterValue(self.DATE_FROM)
date_to = self.getParameterValue(self.DATE_TO)
qgis = JupiterQGIS()
if extent == "0,0,0,0":
if qgis.countSelectedFeatures(extent_layer) != 1:
JupiterAux.msg_box(
u'Der skal være valgt een (og kun en) geometri i {}\nNår afgrænsningen er 0,0,0,0'
.format(extent_layer))
return
# Create plot
mapplot = JupiterMatplot()
result = mapplot.scatterplot(extent,
compoundname1,
compoundname2,
date_from,
date_to,
extent_layer=extent_layer,
x_marker=xaxeline,
y_marker=yaxeline,
showannotations=showannotations)
progress.setPercentage(100)
#if self.tablename == u'Plot Nitrat mod sulfat':
# pgtablename = u'mstmvw_bulk_grwchem_alldates'
#else:
# raise Exception(u'Fejl: Tabel eller view: "{}" findes ikke'.format(self.tablename))
if result:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(u'<br><b>Scatterplot oprettet og åbnet</b>')
else:
progress.setInfo(u'Der er sket en fejl i "{}"'.format(self.name))
def processAlgorithm(self, progress):
"""Here is where the processing itself takes place."""
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(self.name))
progress.setPercentage(50)
extent = self.getParameterValue(self.EXTENT)
extent_layer = self.getParameterValue(self.VECTOR_SELECTION)
date_from = self.getParameterValue(self.DATE_FROM)
date_to = self.getParameterValue(self.DATE_TO)
output = self.getOutputFromName(self.OUTPUT)
where_sql = None
JupiterAux.log_info(u'\nprocessAlgorithm: {}'.format(self.tablename))
if self.tablename == u'Hent alle stoffer fra grundvand (boring)':
pgtablename = u'mstmvw_bulk_grwchem_alldates'
where_sql = u"sampledate > to_date('{}', 'YYYY-MM-DD') AND sampledate < to_date('{}', 'YYYY-MM-DD') AND geom IS NOT NULL".\
format(date_from, date_to)
output.description = 'Alle_stoffer_grw'
elif self.tablename == u'Hent alle stoffer fra vandværk (anlæg)':
pgtablename = u'mstmvw_bulk_pltchem_alldates'
where_sql = u"sampledate > to_date('{}', 'YYYY-MM-DD') AND sampledate < to_date('{}', 'YYYY-MM-DD') AND geom IS NOT NULL".\
format(date_from, date_to)
output.description = 'Alle_stoffer_plt'
else:
raise Exception(u'Fejl: Tabel eller view: "{}" findes ikke'.format(self.tablename))
jq = JupiterQGIS()
ok_add_map = jq.add_maplayer(
progress,
pgtablename,
output,
extent,
selectionLayername=extent_layer,
rowid='row_id',
where_sql2=where_sql)
if ok_add_map:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(self.name))
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(u'<br><b>Tabel med alle stofanalyser er åbnet</b>')
else:
progress.setInfo(u'Der er sket en fejl i "{}"'.format(self.name))
def add_rubberband_borehole(self, boreholeno):
""" Warning - this method fails silently on error """
self.remove_canvas_vertexmarkers()
# Add new rubberband
points = [[
QgsPoint(6640629.039, 6087146.608),
QgsPoint(640629.039, 6087146.608),
QgsPoint(640629.039, 6087146.608),
QgsPoint(6640629.039, 6087146.608)
]] # lower left, upper right
r = QgsRubberBand(iface.mapCanvas, True) # True = a polygon
r.setColor(QColor(0, 255, 0, 255))
r.setWidth(3)
r.setToGeometry(QgsGeometry.fromPolygon(points), None)
JupiterAux.log_info(
u'rubberband added for borehole {}'.format(boreholeno))
def processAlgorithm(self, progress):
"""Here is where the processing itself takes place
"""
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setPercentage(10)
# Get user input
output = self.getOutputFromName(
self.OUTPUT) #<class 'processing.core.outputs.OutputVector'>
pgtablename = ''
if self.dktablename == u'Åbn synchronizationlog':
output.description = u'synchronizationlog'
pgtablename = u'synchronizationlog'
elif self.dktablename == u'Åbn synchronizationevent':
output.description = u'synchronizationevent'
pgtablename = u'synchronizationevent'
elif self.dktablename == u'Åbn exporttime':
output.description = u'exporttime'
pgtablename = u'exporttime'
JupiterAux.log_info(
u'Valgt alphanumeric tabel med pgtablename: {}\n'.format(
pgtablename))
qgis = JupiterQGIS()
ok_add_alphatable = qgis.add_alphaview(progress, pgtablename, output)
progress.setPercentage(100)
if ok_add_alphatable:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(
u'<br><b>Tabel med databasenavn: {} er åbnet som: {}</b>'.
format(pgtablename, output.description))
else:
progress.setText(u'<br><b>Fejl i udtræk. Se log:</b>')
def __init__(self):
AlgorithmProvider.__init__(self)
## Try to clear the message log
# from PyQt4.QtGui import QDockWidget
# from qgis.utils import iface
# consoleWidget = iface.mainWindow().findChild(QDockWidget, 'PythonConsole')
# consoleWidget.console.shellOut.clearConsole()
# MessageLog = iface.mainWindow().findChild(QDockWidget, 'MessageLog')
# for child in iface.mainWindow().children():
# JupiterAux.log_info(child.objectName())
## Explained: Debugger between QGIS and pyCharm
## For the debugger to run the four lines below must be enabled - disable for qgis startup
## Enable the lines - run the debugger from pyCharm - and refresh plugin in QGIS
if 1 == 2:
import sys
sys.path.append(r'C:\Program Files\JetBrains\PyCharm 2017.3.2\debug-eggs\pycharm-debug.egg')
import pydevd
pydevd.settrace('localhost', port=53100, stdoutToServer=True, stderrToServer=True)
# Deactivate provider by default
#self.activate = False
JupiterAux.log_info('\n------------ Qupiter ------------')
# Write out status information
db = JupiterDb()
#JupiterAux.log_info(u'Test DB connection: {}'.format(db.test_connection()))
JupiterAux.log_info(u'{} version:\t\t{}'.format(JupiterAux.JUPITER, JupiterAux.get_meta_version()))
JupiterAux.log_info(u'Sidste komplette restore:\t\t{} dage'.format(db.database_geus_export_time_in_days()))
JupiterAux.log_info(u'Sidste DbSync synkronisation:\t{} dage'.format(db.database_dbsync_success_in_days()))
JupiterAux.log_info(u'Yngste sample insert i databasen:\t{} dage'.format(db.database_youngest_insert_in_days()))
#JupiterAux.log_info('Host: {} -- Database: {} -- User: {}'.format(
#JupiterAux.enable_qgis_log()
#JupiterAux.log_info('Global QGIS log enabled!')
self.createAlgsList()
def addStyle(self, pglayername, vlayer, uri):
"""Add style to layer. Assumes tablename if stylename
:param pglayername: layer to query for in public.layer_styles
:param vlayer: layer to apply style for
:return: True if no error
"""
qmlfile = os.path.join(JupiterAux.pluginpath(), 'style',
'borehole.qml')
msg, styleloaded = vlayer.loadNamedStyle(qmlfile, True)
iface.mapCanvas().refresh()
iface.legendInterface().refreshLayerSymbology(vlayer)
vlayer.triggerRepaint()
return True
JupiterAux.log_info(u'Loading default style from db...')
db = JupiterDb()
styleqml = db.get_style(pglayername)
if styleqml:
#vlayer.applyNamedStyle(pglayername)
styleok = vlayer.loadNamedStyle(styleqml, True)
iface.mapCanvas().refresh()
iface.legendInterface().refreshLayerSymbology(vlayer)
vlayer.triggerRepaint()
JupiterAux.log_info(u'Style applied to: {}'.format(pglayername))
else:
JupiterAux.log_info(
u'Table {} has no default style in db'.format(pglayername))
return True
def processAlgorithm(self, progress):
"""Here is where the processing itself takes place."""
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(self.name))
progress.setPercentage(50)
pgtablename = u'mst_bekendtgoerelse_pesticide_list'
output = self.getOutputFromName(self.OUTPUT) #<class 'processing.core.outputs.OutputVector'>
JupiterAux.log_info('Valgte tabel eller view: {}\n'.format(self.dktablename))
jq = JupiterQGIS()
ok_added = jq.add_alphaview(progress, pgtablename, output)
if ok_added:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(self.name))
progress.setPercentage(100)
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(u'<br><b>Tabel: {} er åbnet med navnet: {}</b>'.format(self.dktablename, pgtablename))
else:
progress.setInfo(u'Der er sket en fejl i "{}"'.format(self.name))
progress.setPercentage(100)
def processAlgorithm(self, progress):
"""Here is where the processing itself takes place."""
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setPercentage(50)
pgtablename = u'borehole'
input = self.getParameterValue(self.INPUT)
fieldname = self.getParameterValue(self.DGUNR_FIELD)
output = self.getOutputFromName(
self.OUTPUT) #<class 'processing.core.outputs.OutputVector'>
JupiterAux.log_info('Valgte tabel med dgunummer: {}\n'.format(
self.dktablename))
jq = JupiterQGIS()
ok_added, str_no_match, str_duplicates = jq.make_dguno_spatial(
progress, pgtablename, input, fieldname, output)
if ok_added:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setPercentage(100)
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(
u'<br><b>Tabel: {} er åbnet med navnet: {}</b>'.format(
pgtablename, self.dktablename))
progress.setText(u'<br><b>BEMÆRK:</b>')
progress.setText(
u'<br><b>Ikke fundet dguno: "{}" og fejl dublere: {}</b><br>'.
format(str_no_match, str_duplicates))
else:
progress.setInfo(u'Der er sket en fejl i "{}"'.format(self.name))
progress.setPercentage(100)
def add_alphaview(self, progress, pglayername, output):
"""Load a non spatial table or view from postgresql - currently pesticide list
:param progress: Information text and progress
:param pglayername: Name of alpha view to load
:param output: processing.core.outputs.OutputVector object
:return: True if no error
"""
db = JupiterDb()
uri = db.getUri()
uri.setDataSource("jupiter", pglayername, None)
JupiterAux.log_info(
'Loading alphalayer: {} from URI'.format(pglayername),
progress=progress)
ok, pglayer = self.getQgsVectorLayerFromUri(uri, pglayername)
if not ok:
return False
if not self.writeOutputVector(
progress, pglayer, output, isSpatial=False):
return False
return True
def processAlgorithm(self, progress):
"""Here is where the processing itself takes place
"""
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setPercentage(10)
# Get user input
extent = self.getParameterValue(self.EXTENT)
maplayerselection = self.getParameterValue(self.VECTOR_SELECTION)
output = self.getOutputFromName(
self.OUTPUT) #<class 'processing.core.outputs.OutputVector'>
rowid = None # rowid on view is compulsory
where_sql = None # Time interval query
if self.dktablename == u'Åbn boringstabellen':
output.description = u'Boringer'
pgtablename = u'borehole'
elif self.dktablename == u'Åbn miljøboringer':
output.description = u'Miljoeboringer'
pgtablename = u'borehole'
where_sql = "(geom is not null) and (use = 'L' or purpose = 'L')"
elif self.dktablename == u'Åbn sløjfede boringer':
output.description = u'Sloejfede boringer'
rowid = 'objectid'
pgtablename = u'mstmvw_boring_canceled'
elif self.dktablename == u'Åbn GRUMO boringer':
output.description = u'GRUMO boringer'
rowid = 'row_id1'
pgtablename = u'mstmvw_grumo_boringer'
elif self.dktablename == u'Åbn anlægstabellen':
output.description = u'Anlaeg'
pgtablename = u'drwplant'
elif self.dktablename == u'Åbn vandforsyningsboringer':
output.description = u'Vandforsyningsboringer'
rowid = 'row_id1'
pgtablename = u'mstmvw_vandforsyningsboringer'
elif self.dktablename == u'Åbn pejlinger':
output.description = u'Pejlinger'
rowid = 'row_id'
pgtablename = u'mstmvw_waterlevel_all_dates'
else:
raise Exception(
u'Tabel eller view: {} findes ikke i metoden_geoalgorithm.processAlgotithm'
.format(self.dktablename))
JupiterAux.log_info(
u'Valgt tabel eller view: {} med pgtablename: {}\n'.format(
self.dktablename, pgtablename))
qgis = JupiterQGIS()
ok_add_map = qgis.add_maplayer(progress,
pgtablename,
output,
extent,
selectionLayername=maplayerselection,
rowid=rowid,
where_sql2=where_sql)
progress.setPercentage(100)
if ok_add_map:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(
u'<br><b>Tabel med databasenavn: {} er åbnet som: {}</b>'.
format(pgtablename, output.description))
else:
progress.setText(u'<br><b>Fejl i udtræk. Se log:</b>')
def processAlgorithm(self, progress):
"""Here is where the processing itself takes place
"""
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(self.name))
progress.setPercentage(10)
# Get user input
extent = self.getParameterValue(self.EXTENT)
maplayerselection = self.getParameterValue(self.VECTOR_SELECTION)
date_to = self.getParameterValue(self.DATE_TO)
date_from = self.getParameterValue(self.DATE_FROM)
onlyload_latest = self.getParameterValue(self.LOAD_ONLY_LATEST)
output = self.getOutputFromName(self.OUTPUT) #<class 'processing.core.outputs.OutputVector'>
where_sql = None # Time interval query
if self.dktablename == u'Beregn vandtype':
output.description = u'Vandtype'
if onlyload_latest:
pgtablename = u'mstmvw_watertype4_latestdate'
else:
pgtablename = u'mstmvw_watertype4_alldates'
where_sql = u"sampledate > to_date('{}', 'YYYY-MM-DD') AND sampledate < to_date('{}', 'YYYY-MM-DD')".format(date_from, date_to)
elif self.dktablename == u'Beregn ionbalance':
output.description = u'Ionbalance'
if onlyload_latest:
pgtablename = u'mstmvw_ionbalance_latest_dates'
else:
pgtablename = u'mstmvw_ionbalance_all_dates'
where_sql = u"sampledate > to_date('{}', 'YYYY-MM-DD') AND sampledate < to_date('{}', 'YYYY-MM-DD')".format(date_from, date_to)
elif self.dktablename == u'Hent uorganiske stoffer':
output.description = u'Uorganiske stoffer'
if onlyload_latest:
pgtablename = u'mstmvw_inorganic_compound_latest_dates'
else:
pgtablename = u'mstmvw_inorganic_compound_all_dates'
where_sql = u"sampledate > to_date('{}', 'YYYY-MM-DD') AND sampledate < to_date('{}', 'YYYY-MM-DD')".format(date_from, date_to)
elif self.dktablename == u'Åbn pejlinger':
output.description = u'Pejlinger'
if onlyload_latest:
pgtablename = u'mstmvw_waterlevel_latest_dates'
else:
pgtablename = u'mstmvw_waterlevel_all_dates'
where_sql = u"pejledato > to_date('{}', 'YYYY-MM-DD') AND pejledato < to_date('{}', 'YYYY-MM-DD')".format(date_from, date_to)
elif self.dktablename == u'Kombineret kemiskudtræk':
output.description = u'Kemi'
if onlyload_latest:
pgtablename = u'mstmvw_combined_chemestry_latestdates'
else:
pgtablename = u'mstmvw_combined_chemestry_alldates'
where_sql = u"sampledate > to_date('{}', 'YYYY-MM-DD') AND sampledate < to_date('{}', 'YYYY-MM-DD')".format(
date_from, date_to)
else:
raise Exception(u'Fejl. tabel eller view: {} findes ikke'.format(self.dktablename))
JupiterAux.log_info(u'Valgt tabel eller view: {} med pgtablename: {}\n'.format(self.dktablename, pgtablename))
jq = JupiterQGIS()
ok_add_map = jq.add_maplayer(
progress,
pgtablename,
output,
extent,
selectionLayername=maplayerselection,
rowid='row_id',
where_sql2=where_sql)
progress.setPercentage(100)
if ok_add_map:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(self.name))
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(u'<br><b>Tabel med databasenavn: {} er åbnet som: {}</b>'.format(pgtablename, output.description))
else:
progress.setText(u'<br><b>Fejl i udtræk. Se log:</b>')
def add_maplayer(self,
progress,
pglayername,
output,
extent,
selectionLayername=None,
rowid=None,
where_sql2=None):
"""Adds a postgis layer to map
:type progress: Processing progressbar and info
:type pglayername: string name of pglayer to select from Jupiter
:param output: processing.core.outputs.OutputVector object
:type extent: Bounding box of query, if none use selected geom(s) as bound
:type selectionLayername: string name of layer with selected geom to use as border in query
:type rowid: needed for qgis to open views
:where_sql: additional sql, not only bound search ... update doc
WARNING: Do not use semicolon after where sql at uri.setDataSource
"""
# import sys
# sys.path.append(r'C:\Program Files\JetBrains\PyCharm 2017.2.3\debug-eggs\pycharm-debug.egg')
# import pydevd
# pydevd.settrace('localhost', port=53100, stdoutToServer=True, stderrToServer=True)
JupiterAux.log_info('add_maplayer: {}'.format(pglayername), progress)
db = JupiterDb()
uri = db.getUri()
where_sql = ''
# https://gis.stackexchange.com/questions/239601/sqlqueries-in-postgis-database-layer-using-python-and-qgis/239682#239682
if extent == "0,0,0,0":
''' Query by geometry of selection in a layer '''
wkt = self.selectedFeatureToWKT(selectionLayername)
if not where_sql2:
where_sql = "ST_WITHIN(geom , ST_GeomFromText('{}', 25832))".format(
wkt)
else:
where_sql = "ST_WITHIN(geom , ST_GeomFromText('{}', 25832) ) AND {}".format(
wkt, where_sql2)
else:
''' Query by entered extent '''
bbox = self.extentToBoundingbox(extent)
if not where_sql2:
where_sql = "geom && ST_MakeEnvelope({}, {}, {}, {}, 25832)". \
format(bbox.xMinimum(), bbox.yMinimum(), bbox.xMaximum(), bbox.yMaximum())
else:
where_sql = "geom && ST_MakeEnvelope({}, {}, {}, {}, 25832) AND {}" \
.format(bbox.xMinimum(), bbox.yMinimum(), bbox.xMaximum(), bbox.yMaximum(), where_sql2)
uri.setDataSource("jupiter", pglayername, "geom", where_sql)
JupiterAux.log_info(
'Loading layer: "{}" from URI with where clause: "{}"'.format(
pglayername, where_sql2),
progress=progress)
# Views must have defined a rowid
if rowid:
uri.setKeyColumn(rowid)
ok, pglayer = self.getQgsVectorLayerFromUri(uri, pglayername)
if not ok:
return False
if not self.writeOutputVector(progress, pglayer, output):
return False
#if not self.addStyle(pglayername, vlayer, uri):
#return False
# TODO layer is not add to map until end of table_geoalgorithm.processAlgorithm
# TODO therefor is the showFeatureCount below not working
# self.showFeatureCount(vlayer.name())
return True
def processAlgorithm(self, progress):
"""Here is where the processing itself takes place."""
progress.setInfo(u'Start querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setPercentage(50)
extent = self.getParameterValue(self.EXTENT)
extent_layer = self.getParameterValue(self.VECTOR_SELECTION)
compoundname = unicode(self.getParameterValue(self.COMPOUNDNAME))
compoundlimit = self.getParameterValue(self.COMPOUNDLIMIT)
date_from = self.getParameterValue(self.DATE_FROM)
date_to = self.getParameterValue(self.DATE_TO)
onlyload_latest = self.getParameterValue(self.LOAD_ONLY_LATEST)
output = self.getOutputFromName(self.OUTPUT)
where_sql = None
db = JupiterDb()
compoundno = db.compoundname_to_no(compoundname)
if compoundno is None:
JupiterAux.msg_box(
u'Stoffet: "{}" findes ikke i PCJupiterXL'.format(
compoundname))
progress.setPercentage(100)
return
JupiterAux.log_info(u'\nprocessAlgorithm: {}'.format(self.tablename))
output.description = compoundname
if self.tablename == u'Søg et stof fra grundvand (boring)':
if onlyload_latest:
pgtablename = u'mstvw_bulk_grwchem_latestdates'
where_sql = u"compoundno = {} AND amount > {} AND geom IS NOT NULL".format(
compoundno, compoundlimit)
else:
pgtablename = u'mstvw_bulk_grwchem' #is alldates
where_sql = u"sampledate > to_date('{}', 'YYYY-MM-DD') AND sampledate < to_date('{}', 'YYYY-MM-DD') AND compoundno = {} AND amount > {} AND geom IS NOT NULL".\
format(date_from, date_to, compoundno, compoundlimit)
elif self.tablename == u'Søg et stof fra vandværk (anlæg)':
if onlyload_latest:
pgtablename = u'mstmvw_bulk_pltchem_latestdates'
where_sql = u"compoundno = {} AND amount > {} AND geom IS NOT NULL".format(
compoundno, compoundlimit)
else:
pgtablename = u'mstmvw_bulk_pltchem_alldates'
where_sql = u"sampledate > to_date('{}', 'YYYY-MM-DD') AND sampledate < to_date('{}', 'YYYY-MM-DD') AND compoundno = {} AND amount > {} AND geom IS NOT NULL".\
format(date_from, date_to, compoundno, compoundlimit)
else:
raise Exception(u'Fejl: Tabel eller view: "{}" findes ikke'.format(
self.tablename))
jq = JupiterQGIS()
ok_add_map = jq.add_maplayer(progress,
pgtablename,
output,
extent,
selectionLayername=extent_layer,
rowid='row_id',
where_sql2=where_sql)
if ok_add_map:
progress.setInfo(u'End querying "{}" in PCJupiterXL...'.format(
self.name))
progress.setText(u'<br><b>RESULTAT:</b>')
progress.setText(
u'<br><b>Tabel {} er åbnet med navnet {}</b>'.format(
self.tablename, compoundname))
else:
progress.setInfo(u'Der er sket en fejl i "{}"'.format(self.name))
