def processAlgorithm(self, parameters, context, feedback):
if Qgis.QGIS_VERSION_INT >= 31400:
connection_name = self.parameterAsConnectionName(
parameters, self.CONNECTION_NAME, context)
schema = self.parameterAsSchema(parameters, self.SCHEMA, context)
else:
connection_name = self.parameterAsString(parameters,
self.CONNECTION_NAME,
context)
schema = self.parameterAsString(parameters, self.SCHEMA, context)
# Set global variable
# noinspection PyCallByClass,PyArgumentList
QgsExpressionContextUtils.setProjectVariable(
context.project(), 'veloroutes_connection_name', connection_name)
feedback.pushInfo(
'Connection PostgreSQL à la base vvv "{}"'.format(connection_name))
QgsExpressionContextUtils.setProjectVariable(context.project(),
'veloroutes_schema',
schema)
feedback.pushInfo(
'Schema PostgreSQL de la base vvv "{}"'.format(schema))
msg = 'La configuration a été faite'
feedback.pushInfo(msg)
status = 1
return {self.OUTPUT_STATUS: status, self.OUTPUT_STRING: msg}
def create_count(self):
layer = self.layers['section']
selected_count = layer.selectedFeatureCount()
if selected_count == 0:
push_info("Veuillez sélectionner un tronçon")
return
elif selected_count > 1:
push_info("Veuillez ne sélectionner qu'un tronçon")
return
else:
selected_feature = next(layer.getSelectedFeatures())
lanes = self.get_lanes_of_section(selected_feature.attribute('id'))
installation = self.get_installation_of_lane(
next(lanes).attribute('id'))
# Save the id of the installation related to the selected section
# so we can use in the count form to automatically select the
# installation in the combobox
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'selected_installation',
installation.attribute('id'))
self.layers['count'].startEditing()
iface.setActiveLayer(self.layers['count'])
iface.actionAddFeature().trigger()
def certificate_preprocess(plot, plots):
"""
Utility function that loads and renders plots that belong to a specific
scheme.
"""
scheme_plot_layer = lht_plot_layer(plot.scheme_id, CERTIFICATE_PLOT)
QgsMapLayerRegistry.instance().addMapLayer(scheme_plot_layer)
# Get the EPSG code of the plot
epsg_code = plot.cb_check_lht_plot_crs.value
# Setting the project CRS variable
QgsExpressionContextUtils.setProjectVariable('flts_source_crs', epsg_code)
# Styling reference plot using primary key
filter_exp = '"id" = ' + str(plot.id)
scheme_symbol = QgsSymbolV2.defaultSymbol(scheme_plot_layer.geometryType())
# Rule-based rendering
rule_renderer = QgsRuleBasedRendererV2(scheme_symbol)
root_rule = rule_renderer.rootRule()
# Rule for highlighting reference plot
scheme_rule = root_rule.children()[0].clone()
scheme_rule.setLabel('Reference Plot')
scheme_rule.setFilterExpression(filter_exp)
scheme_symbol_layer = scheme_rule.symbol().symbolLayer(0)
scheme_symbol_layer.setFillColor(Qt.yellow)
scheme_symbol_layer.setOutlineColor(Qt.black)
scheme_symbol_layer.setBorderWidth(0.5)
root_rule.appendChild(scheme_rule)
# Rule for other plots
def_rule = root_rule.children()[0].clone()
def_rule.setLabel('Plots')
def_rule.setIsElse(True)
def_symbol_layer = def_rule.symbol().symbolLayer(0)
def_symbol_layer.setFillColor(Qt.transparent)
def_symbol_layer.setOutlineColor(Qt.black)
root_rule.appendChild(def_rule)
# Remove default rule
root_rule.removeChildAt(0)
# Set renderer
scheme_plot_layer.setRendererV2(rule_renderer)
# Enable labeling
scheme_plot_layer.setCustomProperty("labeling", "pal")
scheme_plot_layer.setCustomProperty("labeling/enabled", "true")
scheme_plot_layer.setCustomProperty("labeling/fontFamily", "Arial")
scheme_plot_layer.setCustomProperty("labeling/fontSize", "5.5")
scheme_plot_layer.setCustomProperty("labeling/fieldName", "plot_number")
scheme_plot_layer.setCustomProperty("labeling/placement", "1")
scheme_plot_layer.setCustomProperty("labeling/centroidInside", "true")
scheme_plot_layer.setCustomProperty("labeling/centroidWhole", "false")
scheme_plot_layer.triggerRepaint()
iface.mapCanvas().setExtent(scheme_plot_layer.extent())
QgsApplication.processEvents()
return True
def do_export_plan_action(self, count_id):
plan_creator = PlanCreator(self.layers)
file_dialog = QFileDialog()
file_dialog.setDefaultSuffix('*.PDF')
title = 'Exporter plan de pose'
path = os.path.join(self.settings.value('config_export_directory'),
"{}.pdf".format("plan_de_pose"))
file = QFileDialog.getSaveFileName(file_dialog, title, path,
"Config file (*.PDF)")[0]
if not file:
return
# Highlight the current sections and installation in the layout
previous_highlightes_sections = self.layers.highlighted_sections
self.layers.highlighted_sections = \
self.layers.get_section_ids_of_count(count_id)
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'highlighted_installation',
self.layers.get_installation_name_of_count(count_id))
plan_creator.export_pdf(count_id, file)
self.layers.highlighted_sections = previous_highlightes_sections
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'highlighted_installation', '')
self.layers.layers['section'].triggerRepaint()
def changeCurrentIndex(i):
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(),
'level',
self.dockwidget.levelComboBox.currentText()
)
self.iface.mapCanvas().refresh()
def ODKLoadLayerStateAction(self, fileName=None):
if not fileName:
workDir = QgsProject.instance().readPath("./")
fileName = QFileDialog().getOpenFileName(
None, self.tr("Load QGISODK project"), workDir, "*.json")
if fileName:
with open(fileName, "r") as json_file:
restoreDict = json.load(json_file)
ODKProjectName = QFileInfo(fileName).baseName()
self.settingsDlg.importSettings(restoreDict['settings'])
self.dlg.treeView.recover(restoreDict)
self.dlg.setWindowTitle("QGISODK - " + ODKProjectName)
#print restoreDict['targetLayer']['id']
current_idx = self.dlg.layersComboBox.findData(
restoreDict['targetLayer']['id'])
if current_idx == -1:
current_idx = self.dlg.layersComboBox.findText(
restoreDict['targetLayer']['name'])
if current_idx == -1:
current_idx = 0
#print current_idx
#If found sets layers combo box with provided layer, disconnecting update signals....
try:
self.dlg.layersComboBox.currentIndexChanged.disconnect(
self.VectorLayerComboChanged)
except:
pass
self.dlg.layersComboBox.setCurrentIndex(current_idx)
self.dlg.layersComboBox.currentIndexChanged.connect(
self.VectorLayerComboChanged)
S = QSettings()
QgsExpressionContextUtils.setProjectVariable(
'QgisODK_current_project', fileName)
def store_variable(self, name: str, value):
"""Store UI values in the QGIS project variables
:param name: The name of the variable to store
:param value: The value of the variable to store
"""
project = QgsProject.instance()
QgsExpressionContextUtils.setProjectVariable(
project, self.var_format.format(self.prefix, name), value)
def setConvergencia(self, conv):
convergencia = self.generateDMS(conv)
self.convergenciaEdit.setText(convergencia)
proj = QgsProject.instance()
QgsExpressionContextUtils.setProjectVariable(proj, 'convergenciaGMS',
convergencia)
QgsExpressionContextUtils.setProjectVariable(proj, 'convergenciaGD',
conv)
def setDeclinacao(self, decl):
declinacao = self.generateDMS(decl)
self.declinacaoEdit.setText(declinacao)
proj = QgsProject.instance()
QgsExpressionContextUtils.setProjectVariable(proj, 'declinacaoGMS',
declinacao)
QgsExpressionContextUtils.setProjectVariable(proj, 'declinacaoGD',
decl)
def processAlgorithm(self, parameters, context, feedback):
"""Here is where the processing itself takes place."""
for [name,desc,default,paramtype] in self.PROPS:
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(), name,
self.parameterAsString(parameters, name, context))
return {}
def processAlgorithm(self, parameters, context, feedback):
street_layer = self.parameterAsString(parameters, self.STREET_LAYER,
context)
address_layer = self.parameterAsString(parameters, self.ADDRESS_LAYER,
context)
QgsExpressionContextUtils.setProjectVariable(context.project(),
GESTION_ADRESSE_VOIE,
street_layer)
QgsExpressionContextUtils.setProjectVariable(
context.project(), GESTION_ADRESSE_POINT_ADRESSE, address_layer)
return {}
def load_layers(self):
settings = Settings()
group_comptages = QgsProject.instance().layerTreeRoot().findGroup(
'Comptages')
group_extra = QgsProject.instance().layerTreeRoot().findGroup('Extra')
if group_comptages is None:
group_comptages = QgsProject.instance().layerTreeRoot().addGroup(
'Comptages')
if group_extra is None and settings.value("extra_layers"):
group_extra = group_comptages.addGroup('Extra')
for key in LAYER_DEFINITIONS:
layer_definition = LAYER_DEFINITIONS[key]
if not QgsProject.instance().mapLayersByName(
layer_definition['display_name']):
layer = self.load_layer(
'comptages', # Schema
layer_definition['table'],
layer_definition['geometry'],
layer_definition['sql'],
layer_definition['display_name'],
layer_definition['id'],
layer_definition['epsg'],
)
if layer_definition['legend']:
group_comptages.addLayer(layer)
elif settings.value("extra_layers"):
group_extra.addLayer(layer)
self.layers[key] = layer
self.apply_qml_styles()
self.add_layer_actions()
self.create_virtual_fields()
self.create_joins()
self.create_relations()
iface.setActiveLayer(self.layers['section'])
self.populate_list_of_highlighted_sections()
self.layers['count'].featureAdded.connect(self.on_count_added)
from qgis.core import QgsExpressionContextUtils
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'highlighted_installation', '')
def processAlgorithm(self, parameters, context, feedback):
msg = ""
output_layers = []
layers_name = ["commune", "voie", "point_adresse", "parcelle"]
layers_name_none = dict()
layers_name_none["document"] = ""
layers_name_none["v_commune"] = "insee_code"
# override = self.parameterAsBool(parameters, self.OVERRIDE, context)
connection = self.parameterAsString(parameters, self.DATABASE, context)
feedback.pushInfo("## CONNEXION A LA BASE DE DONNEES ##")
uri = uri_from_name(connection)
is_host = uri.host() != ""
if is_host:
feedback.pushInfo("Connexion établie via l'hote")
else:
feedback.pushInfo("Connexion établie via le service")
schema = self.parameterAsString(parameters, self.SCHEMA, context)
feedback.pushInfo("")
feedback.pushInfo("## CHARGEMENT DES COUCHES ##")
for x in layers_name:
if not context.project().mapLayersByName(x):
result = self.initLayer(context, uri, schema, x, "geom", "")
if not result:
feedback.pushInfo("La couche " + x +
" ne peut pas être chargée")
else:
output_layers.append(result.id())
if x == "voie":
QgsExpressionContextUtils.setProjectVariable(
context.project(), GESTION_ADRESSE_VOIE,
result.id())
elif x == "point_adresse":
QgsExpressionContextUtils.setProjectVariable(
context.project(),
GESTION_ADRESSE_POINT_ADRESSE,
result.id(),
)
for x in layers_name_none:
if not context.project().mapLayersByName(x):
result = self.initLayer(context, uri, schema, x, None, "",
layers_name_none[x])
if not result:
feedback.pushInfo("La couche " + x +
" ne peut pas être chargée")
return {self.OUTPUT_MSG: msg, self.OUTPUT: output_layers}
def processAlgorithm(self, parameters, context, feedback):
connection_name = parameters[self.CONNECTION_NAME]
# Set project variable
QgsExpressionContextUtils.setProjectVariable(context.project(), 'gobs_connection_name', connection_name)
feedback.pushInfo(tr('PostgreSQL connection to G-Obs database') + ' = ' + connection_name)
msg = tr('Configuration has been saved')
feedback.pushInfo(msg)
status = 1
return {
self.OUTPUT_STATUS: status,
self.OUTPUT_STRING: msg
}
def doAction(self, layer, uid, feature):
if layer.actions().action(uid).name() == 'openFeatureForm':
self.plugin.iface.openFeatureForm(layer, feature)
else :
ctxt = QgsExpressionContext()
ctxt.appendScope(QgsExpressionContextUtils.globalScope())
ctxt.appendScope(QgsExpressionContextUtils.projectScope(QgsProject.instance()))
ctxt.appendScope(QgsExpressionContextUtils.mapSettingsScope(self.canvas.mapSettings()))
# Add click_x and click_y to context
p = self.toLayerCoordinates(layer, self.pos())
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(), 'click_x', p.x())
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(), 'click_y', p.y())
layer.actions().doAction(uid, feature, ctxt)
def set_project_setting(key: str,
value: Union[str, int, float, bool],
internal: bool = True) -> bool:
"""
Set a value in the QGIS project settings
:param key: Key for the setting
:param value: Value for the setting
:param internal: Whether to search from only plugin settings or all
"""
proj = QgsProject.instance()
if internal:
return proj.writeEntry(plugin_name(), key, value)
else:
QgsExpressionContextUtils.setProjectVariable(proj, key, value)
return True
def write_project_variables(project_owner, project_name, project_full_name,
version, server):
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
"mergin_project_name",
project_name)
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
"mergin_project_owner",
project_owner)
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
"mergin_project_full_name",
project_full_name)
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
"mergin_project_version",
int_version(version))
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
"mergin_project_server",
server)
def ODKSaveLayerStateAction(self):
backupDict = {
'fieldsState': self.dlg.treeView.backup(),
'settings': self.settingsDlg.exportSettings(),
'targetLayer': self.dlg.treeView.targetLayer
}
workDir = QgsProject.instance().readPath("./")
fileName = QFileDialog().getSaveFileName(
None, self.tr("Save QGISODK project"), workDir, "*.json")
if fileName:
if QFileInfo(fileName).suffix() != "json":
fileName += ".json"
with open(fileName, "w") as json_file:
json.dump(backupDict, json_file)
QgsExpressionContextUtils.setProjectVariable('QgisODK_current_project',
fileName)
def setCurrentProposal(self, value):
"""
Set the current proposal
"""
QgsMessageLog.logMessage(
'Current proposal changed to {proposal_id}'.format(
proposal_id=value),
tag="TOMs panel")
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
'CurrentProposal', value)
self.currProposalObject.setProposal(self.currentProposal())
self.proposalChanged.emit()
self.updateMapCanvas()
box = self.currProposalObject.getProposalBoundingBox()
if box.isNull() == False:
self.canvas.setExtent(box)
def saveState(self):
"""
Makes sure all added workflows are stored to active instance of
QgsProject, making it "loadable" along with saved QGIS projects.
"""
# workflow objects cannot be serialized, so they must be passed as dict
workflows = dict()
for w in self.workflows.values():
workflows[w.displayName()] = w.asDict()
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(),
"dsgtools_qatoolbox_state",
json.dumps({
"workflows" : workflows,
"current_workflow" : self.comboBox.currentIndex(),
"showButtons" : self._showButtons
})
)
def doAction(self, layer, uid, feature):
if layer.actions().action(uid).name() == 'openFeatureForm':
self.plugin.iface.openFeatureForm(layer, feature)
else:
ctxt = QgsExpressionContext()
ctxt.appendScope(QgsExpressionContextUtils.globalScope())
ctxt.appendScope(
QgsExpressionContextUtils.projectScope(QgsProject.instance()))
ctxt.appendScope(
QgsExpressionContextUtils.mapSettingsScope(
self.canvas.mapSettings()))
# Add click_x and click_y to context
p = self.toLayerCoordinates(layer, self.pos())
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'click_x', p.x())
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'click_y', p.y())
layer.actions().doAction(uid, feature, ctxt)
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
connection_name = self.parameterAsString(parameters, self.CONNECTION_NAME, context)
# Set global variable
# noinspection PyCallByClass,PyArgumentList
QgsExpressionContextUtils.setProjectVariable(
context.project(), 'veloroutes_connection_name', connection_name
)
feedback.pushInfo('Connection PostgreSQL à la base vvv "{}"'.format(connection_name))
msg = 'La configuration a été faite'
feedback.pushInfo(msg)
status = 1
return {
self.OUTPUT_STATUS: status,
self.OUTPUT_STRING: msg
}
def run(self):
"""Run method that loads and starts the plugin"""
if not self.pluginIsActive:
self.pluginIsActive = True
#print "** STARTING variablesLiveChanger"
# dockwidget may not exist if:
# first run of plugin
# removed on close (see self.onClosePlugin method)
if self.dockwidget == None:
# Create the dockwidget (after translation) and keep reference
self.dockwidget = variablesLiveChangerDockWidget()
# Default level
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'level', '0')
self.dockwidget.levelComboBox.setCurrentIndex(5)
def changeCurrentIndex(i):
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(),
'level',
self.dockwidget.levelComboBox.currentText()
)
self.iface.mapCanvas().refresh()
self.dockwidget.levelComboBox.currentIndexChanged.connect(
changeCurrentIndex
)
self.iface.mapCanvas().refresh()
# connect to provide cleanup on closing of dockwidget
self.dockwidget.closingPlugin.connect(self.onClosePlugin)
# show the dockwidget
# TODO: fix to allow choice of dock location
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget)
self.dockwidget.show()
def write_project_variables(project_owner, project_name, project_full_name,
version):
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
'mergin_project_name',
project_name)
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
'mergin_project_owner',
project_owner)
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
'mergin_project_full_name',
project_full_name)
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
'mergin_project_version',
int_version(version))
def canvasReleaseEvent(self, event):
"""On click, do action"""
if not self.plugin.active:
return
# left click only
if event.button() not in (Qt.LeftButton, Qt.RightButton):
return
self.__pos = event.pos()
# Add click_x and click_y to context
if self.pos():
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), "click_x",
self.pos().x())
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), "click_y",
self.pos().y())
self.findUnderlyingObjects(event, True)
# if a single action (2 lines in the list)
if len(self.featuresFound) == 1:
layer = self.featuresFound[0]["layer"]
id = self.featuresFound[0]["idxAction"]
feature = self.featuresFound[0]["feature"]
self.doAction(layer, id, feature)
else:
# to choose the action to trigger
canvasPos = self.canvas.mapToGlobal(QPoint(0, 0))
self.chooserDlg = ChooserDlg(
self,
self.featuresFound,
canvasPos.x() + self.__pos.x(),
canvasPos.y() + self.__pos.y(),
)
self.chooserDlg.go()
def fit_curve(self):
try:
import numpy as np
import scipy.optimize
except ImportError:
self.iface.messageBar().pushMessage(
"Atitude correction",
"Cannot import numpy and/or scipy - cannot run fit",
level=Qgis.Warning,
duration=3)
return ()
self.iface.messageBar().pushMessage("Atitude correction",
"Running ...",
level=Qgis.Success,
duration=3)
# https://swharden.com/blog/2020-09-24-python-exponential-fit/
# NTB - calc from waterdata
#
NTBact = self.waterdata[1]
ntb = sum(NTBact) / len(NTBact)
QgsExpressionContextUtils.setProjectVariable(QgsProject.instance(),
'altitudecorrection_ntb',
ntb)
print(ntb)
self.dlg.leNTB.setText(str(round(ntb, 6)))
#waterfit=self.fit(self.waterdata)
#print(waterfit)
#print(waterfit[1])
# "Canned" parameters
# ntb=4.284670
# ntbfactor=0.001743
# ntb0=ntb+ntbfactor
# expfactor=-0.006383
# gmmdown=(value1-ntb)*math.exp(expfactor)/math.exp(expfactor*value2)+ ntb0
calibdata = []
# Subtracting ntb to get only terrestrial background
calibdata = [x - ntb for x in self.landdata[1]]
p0 = (50, 0.006, ntb)
params, cv = scipy.optimize.curve_fit(self.monoExp, self.landdata[0],
calibdata, p0)
dose0, alpha, offset = params
self.dlg.leDose0.setText(str(round(dose0, 6)))
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'altitudecorrection_dose0',
float(dose0)) # params[0])
self.dlg.leAlpha.setText(str(round(params[1], 6)))
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'altitudecorrection_alpha',
float(alpha)) # params[1])
def makeShowZonesPdf():
self.cursor.execute(Const.ZONES_QUERY, [int(feature[id_index])])
rows = (row for row in self.cursor.fetchall() if row[Const.ZONES_COLUMNS.index('per_int')] >= 3)
composition = None
for item in self.iface.activeComposers():
if item.composerWindow().windowTitle() == Const.PDF_ZONES:
composition = item.composition()
break
if composition is None:
return
filename = os.path.join(self.reports_folder, '{}_zones.pdf'.format(info[Const.REFCAT]))
printer = QPrinter()
composition.beginPrintAsPDF(printer, filename)
composition.beginPrint(printer, False)
painter = QPainter()
painter.begin(printer)
first = True
for data in rows:
if first:
first = False
else:
printer.newPage()
for i, column in enumerate(Const.ZONES_COLUMNS):
QgsExpressionContextUtils.setProjectVariable(column, data[i])
if info[Const.CODI_SECTOR] is not None:
QgsExpressionContextUtils.setProjectVariable('sec_descripcio', u'{} - {}'.format(info[Const.CODI_SECTOR], info[Const.DESCR_SECTOR]))
else:
QgsExpressionContextUtils.setProjectVariable('sec_descripcio', None)
QgsExpressionContextUtils.setProjectVariable('cla_descripcio', u'{} - {}'.format(info[Const.CODI_CLASSI], info[Const.DESCR_CLASSI]))
composition.refreshItems()
composition.doPrint(printer, painter)
painter.end()
openFile(filename)
def refreshed():
# Disconnect signal
self.iface.mapCanvas().mapCanvasRefreshed.disconnect(refreshed)
# Get composition
composition = None
for item in self.iface.activeComposers():
if item.composerWindow().windowTitle() == Const.PDF_UBICACIO:
composition = item.composition()
break
if composition is None:
return
# Set values
QgsExpressionContextUtils.setProjectVariable('refcat', info[Const.REFCAT])
QgsExpressionContextUtils.setProjectVariable('area', '{:.0f}'.format(info[Const.AREA]))
QgsExpressionContextUtils.setProjectVariable('adreca', info[Const.ADRECA])
# Set main map to the propper position
main_map = composition.getComposerItemById('Mapa principal')
centerMap(main_map, feature)
# Add temporal layer to composition
legend = composition.getComposerItemById('Llegenda')
legend_root = legend.modelV2().rootGroup()
legend_root.insertLayer(0, vl)
# Make PDF
filename = os.path.join(self.reports_folder, '{}_ubicacio.pdf'.format(info[Const.REFCAT]))
if composition.exportAsPDF(filename):
openFile(filename)
else:
self.error(u"No s'ha pogut convertir a PDF.")
# Delete temporary layer
legend_root.removeLayer(vl)
QgsMapLayerRegistry.instance().removeMapLayers([vl.id()])
# Repaint again
self.iface.mapCanvas().refresh()
def setProjectVariable(project, variable, value):
if (project is not None):
QgsExpressionContextUtils.setProjectVariable(project, variable, value)
def updateVars(self):
"""Set the value of the variables from the user-entered values in the Edit Metadata tab"""
# Initialise progressbar
i = 0
QApplication.setOverrideCursor(Qt.BusyCursor)
currProject = QgsProject.instance()
self.dlg.updateBar.setValue(0)
self.dlg.updateBar.setMaximum(11)
# self.dlg.layoutSelect.currentIndex():
title = self.dlg.layoutSelect.currentText()
self.dlg.printinglabel.setText(
self.tr(u'Updating {}...').format(title))
# process input events in order to allow canceling
QCoreApplication.processEvents()
# Project: update variables from dialog
QgsExpressionContextUtils.setProjectVariable(currProject, 'ma_country',
self.dlg.maCountry.text())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
QgsExpressionContextUtils.setProjectVariable(currProject,
'ma_glide_number',
self.dlg.maGlide.text())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
QgsExpressionContextUtils.setProjectVariable(currProject, 'ma_crs',
self.dlg.maCrs.text())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
QgsExpressionContextUtils.setProjectVariable(
currProject, 'ma_organisation', self.dlg.maOrganisation.text())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
QgsExpressionContextUtils.setProjectVariable(currProject, 'ma_country',
self.dlg.maCountry.text())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
QgsExpressionContextUtils.setProjectVariable(
currProject, 'ma_opid', self.dlg.maOperationID.text())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
QgsExpressionContextUtils.setProjectVariable(
currProject, 'ma_acknowledgements',
self.dlg.maAcknowledgements.toPlainText())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
QgsExpressionContextUtils.setProjectVariable(
currProject, 'ma_disclaimer', self.dlg.maDisclaimer.toPlainText())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Layout: update variables from dialog
for layout in QgsProject.instance().layoutManager().printLayouts():
# Select the current layout
if layout.name() == self.dlg.layoutSelect.currentText():
QgsMessageLog.logMessage(
'Info: value for ' + self.dlg.maSummary.toPlainText(),
'MapExport')
# Map Number
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_map_number', self.dlg.maMapNumber.text())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Map Title
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_title', self.dlg.maTitle.text())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Date Created
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_created', self.dlg.maCreated.date())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Map Summary
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_summary', self.dlg.maSummary.toPlainText())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Data sources
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_datasource',
self.dlg.maDatasource.toPlainText())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Version
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_version', self.dlg.maVersion.value())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Status
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_status', self.dlg.maStatus.currentText())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Access
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_access', self.dlg.maAccess.currentText())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
# Language
QgsExpressionContextUtils.setLayoutVariable(
layout, 'ma_language', self.dlg.maLanguage.currentText())
self.dlg.updateBar.setValue(self.dlg.updateBar.value() + 1)
i = i + 1
QApplication.restoreOverrideCursor()
# show an ending message
# in case of abortion
if self.arret:
self.iface.messageBar().pushMessage(
self.tr(u'Operation interrupted : '),
self.tr(u'Maps on {} have been '\
'exported to "{}" before cancelling. '\
'Some files may be incomplete.'
).format(i,folder),
level = Qgis.Info, duration = 10
)
# or when export ended completely
else:
self.iface.messageBar().pushMessage(
self.tr(u'Operation finished : '),
self.tr(u'The metadata has been '\
'updated.'
).format(title),
level = Qgis.Info, duration = 50
)
def populateMetadataItems(self, m, layout):
"""Get the current value of metadata items from the project or layout variable, and populate the Edit Metadata dialog
See *updateVars* to populate variable values from th Edit Metadata UI
"""
currProject = QgsProject.instance()
# Check that all the variables exist, and if they don't, create them and give them a default value where appropriate
with open(os.path.join(self.plugin_dir, "input/metadata_items.csv"),
'r') as metadata_file:
reader = csv.reader(metadata_file, delimiter=',')
metadata_list = list(reader)
for x in metadata_list:
ma_variable = str(x[0])
elem_name = str(x[1])
elem_name = elem_name.strip()
ma_level = str(x[2])
default_value = str(x[3])
ma_level = ma_level.strip()
# If project level variables don't exist, create them and populate with the default value
if (ma_level == 'project'):
if str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable)) == 'None':
QgsExpressionContextUtils.setProjectVariable(
currProject, ma_variable, default_value)
# Populate comboboxes
# Populate values of Status combobox
self.dlg.maStatus.addItem('New')
self.dlg.maStatus.addItem('Correction')
self.dlg.maStatus.addItem('Update')
# Populate values of Access combobox
self.dlg.maAccess.addItem('Public')
self.dlg.maAccess.addItem('MapAction')
self.dlg.maAccess.addItem('Selected partners')
# Populate values of Language combobox
self.dlg.maLanguage.addItem('English')
self.dlg.maLanguage.addItem('French')
self.dlg.maLanguage.addItem('Spanish')
# Populate the Edit Metadata dialog with current values from variables
for x in m:
ma_variable = str(x[0])
elem_name = str(x[1])
elem_name = elem_name.strip()
ma_level = str(x[2])
ma_level = ma_level.strip()
default_value = str(x[3])
proj_crs = QgsProject.instance().crs()
if (ma_level == 'project'):
# Project: get current value for each variable from project and populate field
if ma_variable == 'ma_country':
self.dlg.maCountry.setText(
str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable)))
elif ma_variable == 'ma_crs':
self.dlg.maCrs.setText(
str(
QgsCoordinateReferenceSystem(
proj_crs).description()))
elif ma_variable == 'ma_glide_number':
self.dlg.maGlide.setText(
str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable)))
elif ma_variable == 'ma_organisation':
self.dlg.maOrganisation.setText(
str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable)))
elif ma_variable == 'ma_opid':
self.dlg.maOperationID.setText(
str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable)))
elif ma_variable == 'ma_sourceorg':
self.dlg.maSourceOrg.setText(
str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable)))
elif ma_variable == 'ma_acknowledgements':
self.dlg.maAcknowledgements.setText(
str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable)))
elif ma_variable == 'ma_disclaimer':
self.dlg.maDisclaimer.setText(
str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable)))
# Layout: Get the current value of the variable if it exists and populate the field
elif (ma_level == 'layout'):
for layout in QgsProject.instance().layoutManager(
).printLayouts():
# If the variable doesn't exist, create it
if layout.name() == self.dlg.layoutSelect.currentText():
if str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)) == 'None':
QgsExpressionContextUtils.setLayoutVariable(
layout, ma_variable, default_value)
elif ma_variable == 'ma_map_number':
self.dlg.maMapNumber.setText(
str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)))
elif ma_variable == 'ma_summary':
self.dlg.maSummary.setText(
str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)))
elif ma_variable == 'ma_datasource':
self.dlg.maDatasource.setText(
str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)))
elif ma_variable == 'ma_title':
self.dlg.maTitle.setText(
str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)))
elif ma_variable == 'ma_version':
self.dlg.maVersion.setValue(
int(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)))
elif ma_variable == 'ma_status':
self.dlg.maStatus.setCurrentText(
str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)))
elif ma_variable == 'ma_access':
self.dlg.maAccess.setCurrentText(
str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)))
elif ma_variable == 'ma_language':
self.dlg.maLanguage.setCurrentText(
str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable)))
else:
# ACTION: update or remove this message
QgsMessageLog.logMessage('Warning: level ' + str(ma_level),
'MapExport')