CEN38/Plugin_QGIS
Template
3
0
Fork 0
forked from CEN-RA/Plugin_QGIS
Code Issues Pull Requests Releases 1 Activity

Téléverser les fichiers vers "CenRa_Metabase"

Browse Source
This commit is contained in:
Tom LAVEILLE 2024-08-02 10:20:26 +02:00
parent 0d9fcd8de9
commit 812412c6f9
5 changed files with 1440 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
CenRa_Metabase/CenRa_Metabase.py Normal file
View File

@ -0,0 +1,199 @@
__copyright__ = "Copyright 2021, 3Liz"
__license__ = "GPL version 3"
__email__ = "info@3liz.org"
from qgis.core import QgsApplication
from qgis.PyQt.QtCore import QCoreApplication, Qt, QTranslator, QUrl
from qgis.PyQt.QtGui import QDesktopServices, QIcon
from qgis.PyQt.QtWidgets import QAction, QMessageBox
from qgis.utils import iface
'''
from pg_metadata.connection_manager import (
store_connections,
validate_connections_names,
)
from pg_metadata.locator import LocatorFilter
from pg_metadata.processing.provider import PgMetadataProvider
from pg_metadata.qgis_plugin_tools.tools.custom_logging import setup_logger
'''
from CenRa_Metabase.resources.i18n import setup_translation, tr
import os
from CenRa_Metabase.resources.resources import (
plugin_path,
resources_path,
maj_verif,
)
from CenRa_Metabase.dock import CenRa_Metabase
from CenRa_Metabase.editor import Metabase_Editor
#from CenRa_Metabase.issues import CenRa_Issues
class PgMetadata:
def __init__(self):
""" Constructor. """
self.dock = None
self.editor = None
# self.issues = None
self.provider = None
self.locator_filter = None
self.dock_action = None
self.help_action = None
plugin_dir = os.path.dirname(__file__)
end_find = plugin_dir.rfind('\\')+1
global NAME
NAME = plugin_dir[end_find:]
maj_verif(NAME)
# setup_logger('pg_metadata')
locale, file_path = setup_translation(
folder=plugin_path("i18n"), file_pattern="CenRa_Metabase_{}.qm")
if file_path:
self.translator = QTranslator()
self.translator.load(file_path)
# noinspection PyCallByClass,PyArgumentList
QCoreApplication.installTranslator(self.translator)
# noinspection PyPep8Naming
#def initProcessing(self):
#""" Add the QGIS Processing provider. """
#if not self.provider:
#self.provider = PgMetadataProvider()
#QgsApplication.processingRegistry().addProvider(self.provider)
# noinspection PyPep8Naming
def initGui(self):
""" Build the plugin GUI. """
#self.initProcessing()
#self.check_invalid_connection_names()
self.toolBar = iface.addToolBar("CenRa_Metabase")
self.toolBar.setObjectName("CenRa_Metabase")
icon = QIcon(resources_path('icons', 'icon.png'))
icon2 = QIcon(resources_path('icons', 'icon_2.png'))
# Open the online help
self.help_action = QAction(icon, 'CenRa_Metabase', iface.mainWindow())
iface.pluginHelpMenu().addAction(self.help_action)
self.help_action.triggered.connect(self.open_help)
if not self.editor:
self.editor = Metabase_Editor()
self.editor_action = QAction(icon2, 'CenRa_Metabase',None)
self.toolBar.addAction(self.editor_action)
self.editor_action.triggered.connect(self.open_editor)
if not self.dock:
self.dock = CenRa_Metabase()
iface.addDockWidget(Qt.RightDockWidgetArea, self.dock)
# Open/close the dock from plugin menu
self.dock_action = QAction(icon, 'CenRa_Metabase', iface.mainWindow())
iface.pluginMenu().addAction(self.dock_action)
self.dock_action.triggered.connect(self.open_dock)
# if not self.issues:
# self.issues = CenRa_Issues()
# self.issues_action = QAction(icon, 'CenRa_Metabase',None)
# self.toolBar.addAction(self.issues_action)
# self.issues_action.triggered.connect(self.open_issues)
'''
if not self.locator_filter:
self.locator_filter = LocatorFilter(iface)
iface.registerLocatorFilter(self.locator_filter)
@staticmethod
def check_invalid_connection_names():
""" Check for invalid connection names in the QgsSettings. """
valid, invalid = validate_connections_names()
n_invalid = len(invalid)
if n_invalid == 0:
return
invalid_text = ', '.join(invalid)
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setWindowTitle(tr('PgMetadata: Database connection(s) not available'))
msg.setText(tr(
f'{n_invalid} connection(s) listed in PgMetadata’s settings are invalid or '
f'no longer available: {invalid_text}'))
msg.setInformativeText(tr(
'Do you want to remove these connection(s) from the PgMetadata settings? '
'(You can also do this later with the “Set Connections” tool.)'))
msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
clicked = msg.exec()
if clicked == QMessageBox.Yes:
iface.messageBar().pushSuccess('PgMetadata', tr(f'{n_invalid} invalid connection(s) removed.'))
store_connections(valid)
if clicked == QMessageBox.No:
iface.messageBar().pushInfo('PgMetadata', tr(f'Keeping {n_invalid} invalid connections.'))
'''
def open_help():
""" Open the online help. """
QDesktopServices.openUrl(QUrl('https://plateformesig.cenra-outils.org/'))
def open_dock(self):
""" Open the dock. """
self.dock.show()
self.dock.raise_()
def open_editor(self):
self.editor.show()
self.editor.raise_()
# def open_issues(self):
# self.issues.show()
# self.issues.raise_()
def unload(self):
""" Unload the plugin. """
if self.editor:
iface.removePluginMenu(tr('CenRa_Metabase'),self.editor_action)
#self.editor.removeToolBarIcon(self.editor_action)
if self.dock:
iface.removeDockWidget(self.dock)
self.dock.deleteLater()
if self.provider:
QgsApplication.processingRegistry().removeProvider(self.provider)
del self.provider
if self.locator_filter:
iface.deregisterLocatorFilter(self.locator_filter)
del self.locator_filter
if self.dock_action:
iface.pluginMenu().removeAction(self.dock_action)
del self.dock_action
if self.help_action:
iface.pluginHelpMenu().removeAction(self.help_action)
del self.help_action
@staticmethod
def run_tests(pattern='test_*.py', package=None):
"""Run the test inside QGIS."""
try:
from pathlib import Path
from pg_metadata.qgis_plugin_tools.infrastructure.test_runner import (
test_package,
)
if package is None:
package = '{}.__init__'.format(Path(__file__).parent.name)
test_package(package, pattern)
except (AttributeError, ModuleNotFoundError):
message = 'Could not load tests. Are you using a production package?'
print(message) # NOQA

10
CenRa_Metabase/__init__.py Normal file
View File

@ -0,0 +1,10 @@
__copyright__ = "Copyright 2021, 3Liz"
__license__ = "GPL version 3"
__email__ = "info@3liz.org"
# noinspection PyPep8Naming
def classFactory(iface): # pylint: disable=invalid-name
_ = iface
from CenRa_Metabase.CenRa_Metabase import PgMetadata
return PgMetadata()

481
CenRa_Metabase/dock.py Normal file
View File

@ -0,0 +1,481 @@
"""Dock file."""
__copyright__ = 'Copyright 2020, 3Liz'
__license__ = 'GPL version 3'
__email__ = 'info@3liz.org'
import logging
import os
from collections import namedtuple
from enum import Enum
from functools import partial
from pathlib import Path
from xml.dom.minidom import parseString
from qgis.core import (
NULL,
QgsApplication,
QgsDataSourceUri,
QgsProject,
QgsProviderConnectionException,
QgsProviderRegistry,
QgsRasterLayer,
QgsSettings,
QgsVectorLayer,
)
from qgis.PyQt.QtCore import QLocale, QUrl
from qgis.PyQt.QtGui import QDesktopServices, QIcon
from qgis.PyQt.QtPrintSupport import QPrinter
from qgis.PyQt.QtWebKitWidgets import QWebPage
from qgis.PyQt.QtWidgets import (
QDialog,
QAction,
QDockWidget,
QFileDialog,
QInputDialog,
QMenu,
QToolButton,
)
from qgis.gui import *
from qgis.utils import iface
'''
from pg_metadata.connection_manager import (
check_pgmetadata_is_installed,
connections_list,
settings_connections_names,
)
'''
from CenRa_Metabase.resources.i18n import tr
from CenRa_Metabase.resources.resources import (
load_ui,
resources_path,
login_base,
)
DOCK_CLASS = load_ui('CenRa_Metabase_dockwidget_base.ui')
LOGGER = logging.getLogger('CenRa_Metabase')
class Format(namedtuple('Format', ['label', 'ext'])):
""" Format available for exporting metadata. """
pass
class OutputFormats(Format, Enum):
""" Output format for a metadata sheet. """
PDF = Format(label='PDF', ext='pdf')
HTML = Format(label='HTML', ext='html')
DCAT = Format(label='DCAT', ext='xml')
class CenRa_Metabase(QDockWidget, DOCK_CLASS):
def __init__(self, parent=None):
_ = parent
super().__init__()
self.setupUi(self)
self.settings = QgsSettings()
self.current_datasource_uri = None
self.current_connection = None
self.viewer.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.viewer.page().linkClicked.connect(self.open_link)
# Help button
self.external_help.setText('')
self.external_help.setIcon(QIcon(QgsApplication.iconPath('mActionHelpContents.svg')))
self.external_help.clicked.connect(self.open_external_help)
# Flat table button
self.flatten_dataset_table.setText('')
self.flatten_dataset_table.setToolTip(tr("Add the catalog table"))
self.flatten_dataset_table.setIcon(QgsApplication.getThemeIcon("/mActionAddHtml.svg"))
#self.flatten_dataset_table.clicked.connect(self.add_flatten_dataset_table)
# Settings menu
self.config.setAutoRaise(True)
self.config.setToolTip(tr("Settings"))
self.config.setPopupMode(QToolButton.InstantPopup)
self.config.setIcon(QgsApplication.getThemeIcon("/mActionOptions.svg"))
self.auto_open_dock_action = QAction(
tr('Auto open dock from locator'),
iface.mainWindow())
self.auto_open_dock_action.setCheckable(True)
self.auto_open_dock_action.setChecked(
self.settings.value("pgmetadata/auto_open_dock", True, type=bool)
)
self.auto_open_dock_action.triggered.connect(self.save_auto_open_dock)
menu = QMenu()
menu.addAction(self.auto_open_dock_action)
self.config.setMenu(menu)
# Setting PDF/HTML menu
self.save_button.setAutoRaise(True)
self.save_button.setToolTip(tr("Save metadata"))
self.save_button.setPopupMode(QToolButton.InstantPopup)
self.save_button.setIcon(QIcon(QgsApplication.iconPath('mActionFileSave.svg')))
self.save_as_pdf = QAction(
tr('Enregistrer en PDF') + '…',
iface.mainWindow())
self.save_as_pdf.triggered.connect(partial(self.export_dock_content, OutputFormats.PDF))
self.save_as_html = QAction(
tr('Enregistrer en HTML') + '…',
iface.mainWindow())
self.save_as_html.triggered.connect(partial(self.export_dock_content, OutputFormats.HTML))
self.save_as_dcat = QAction(
tr('Enregistrer en DCAT') + '…',
iface.mainWindow())
self.save_as_dcat.triggered.connect(partial(self.export_dock_content, OutputFormats.DCAT))
self.menu_save = QMenu()
self.menu_save.addAction(self.save_as_pdf)
self.menu_save.addAction(self.save_as_html)
self.menu_save.addAction(self.save_as_dcat)
self.save_button.setMenu(self.menu_save)
self.save_button.setEnabled(False)
self.metadata = QgsProviderRegistry.instance().providerMetadata('postgres')
# Display message in the dock
#if not settings_connections_names():
#self.default_html_content_not_installed()
#else:
self.default_html_content_not_pg_layer()
iface.layerTreeView().currentLayerChanged.connect(self.layer_changed)
if iface.activeLayer():
layer=iface.activeLayer()
iface.layerTreeView().setCurrentLayer(None)
iface.layerTreeView().setCurrentLayer(layer)
def export_dock_content(self, output_format: OutputFormats):
""" Export the current displayed metadata sheet to the given format. """
layer_name = iface.activeLayer().name()
file_path = os.path.join(
self.settings.value("UI/lastFileNameWidgetDir"),
'{name}.{ext}'.format(name=layer_name, ext=output_format.ext)
)
output_file = QFileDialog.getSaveFileName(
self,
tr("Enregistrer en {format}").format(format=output_format.label),
file_path,
"{label} (*.{ext})".format(
label=output_format.label,
ext=output_format.ext,
)
)
if output_file[0] == '':
return
self.settings.setValue("UI/lastFileNameWidgetDir", os.path.dirname(output_file[0]))
output_file_path = output_file[0]
parent_folder = str(Path(output_file_path).parent)
if output_format == OutputFormats.PDF:
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPageMargins(20, 20, 20, 20, QPrinter.Millimeter)
printer.setOutputFileName(output_file_path)
self.viewer.print(printer)
iface.messageBar().pushSuccess(
tr("Export PDF"),
tr(
"The metadata has been exported as PDF successfully in "
"<a href=\"{}\">{}</a>").format(parent_folder, output_file_path)
)
elif output_format in [OutputFormats.HTML,OutputFormats.DCAT]:
if output_format == OutputFormats.HTML:
data_str = self.viewer.page().currentFrame().toHtml()
else:
layer = iface.activeLayer()
uri = layer.dataProvider().uri()
dataall = self.sql_info(uri)
data = self.sql_to_xml(dataall)
with open(resources_path('xml', 'dcat.xml'), encoding='utf8') as xml_file:
xml_template = xml_file.read()
xml = parseString(xml_template.format(language=data[0][0], content=data[0][1]))
data_str = xml.toprettyxml()
with open(output_file[0], "w", encoding='utf8') as file_writer:
file_writer.write(data_str)
iface.messageBar().pushSuccess(
tr("Export") + ' ' + output_format.label,
tr(
"The metadata has been exported as {format} successfully in "
"<a href=\"{folder}\">{path}</a>").format(
format=output_format.label, folder=parent_folder, path=output_file_path)
)
def save_auto_open_dock(self):
""" Save settings about the dock. """
self.settings.setValue("pgmetadata/auto_open_dock", self.auto_open_dock_action.isChecked())
def sql_to_xml(self,dataall):
distribution=''
for y in dataall[1]:
distribution = distribution + (
'<dcat:distribution>'+
'<dcat:Distribution>'+
'<dct:title>{data}</dct:title>'.format(data=y[0])+
'<dcat:downloadURL>{data}</dcat:downloadURL>'.format(data=y[1])+
'<dcat:mediaType>{data}</dcat:mediaType>'.format(data=y[2])+
'<dct:format>{data}</dct:format>'.format(data=y[3])+
'<dct:bytesize>{data}</dct:bytesize>'.format(data=y[4])+
'</dcat:Distribution>'+
'</dcat:distribution>')
publisher=''
for z in dataall[2]:
publisher = publisher + (
'<dct:publisher>'+
'<foaf:Organization>'+
'<foaf:name>{data}</foaf:name>'.format(data=z[1])+
'<foaf:mbox>{data}</foaf:mbox>'.format(data=z[3])+
'</foaf:Organization>'+
'</dct:publisher>')
data_str = [[dataall[0][26],
'<dct:identifier>{data}</dct:identifier>'.format(data=dataall[0][1])+
'<dct:title>{data}</dct:title>'.format(data=dataall[0][4])+
'<dct:description>{data}</dct:description>'.format(data=dataall[0][5])+
'<dct:language>{data}</dct:language>'.format(data=dataall[0][26])+
'<dct:spatial>{data}</dct:spatial>'.format(data=dataall[0][28])+
'<dct:created rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">{data}</dct:created>'.format(data=dataall[0][20])+
'<dct:issued rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">{data}</dct:issued>'.format(data=dataall[0][11])+
'<dct:modified rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">{data}</dct:modified>'.format(data=dataall[0][21])+
'<dct:license>{data}</dct:license>'.format(data=dataall[0][13])+
distribution+
publisher+
'<dcat:theme>{data}</dcat:theme>'.format(data=", ".join(str(x) for x in dataall[0][24]))+
'<dcat:keyword>{data}</dcat:keyword>'.format(data=", ".join(str(x) for x in dataall[0][6]))+
'<dct:accrualPeriodicity>{data}</dct:accrualPeriodicity>'.format(data=dataall[0][12])]]
return data_str
@staticmethod
def sql_for_layer(uri, output_format: OutputFormats):
""" Get the SQL query for a given layer and output format. """
locale = QgsSettings().value("locale/userLocale", QLocale().name())
locale = locale.split('_')[0].lower()
if output_format == [OutputFormats.HTML,OutputFormats.DCAT]:
sql = (
"SELECT pgmetadata.get_dataset_item_html_content('{schema}', '{table}', '{locale}');"
).format(schema=uri.schema(), table=uri.table(), locale=locale)
else:
raise NotImplementedError('Output format is not yet implemented.')
return sql
def layer_changed(self, layer):
""" When the layer has changed in the legend, we must check this new layer. """
self.current_datasource_uri = None
self.current_connection = None
self.ce_trouve_dans_psql(layer)
def add_flatten_dataset_table(self):
""" Add a flatten dataset table with all links and contacts. """
'''
connections, message = connections_list()
if not connections:
LOGGER.critical(message)
self.set_html_content('PgMetadata', message)
return
if len(connections) > 1:
dialog = QInputDialog()
dialog.setComboBoxItems(connections)
dialog.setWindowTitle(tr("Database"))
dialog.setLabelText(tr("Choose the database to add the catalog"))
if not dialog.exec_():
return
connection_name = dialog.textValue()
else:
connection_name = connections[0]
metadata = QgsProviderRegistry.instance().providerMetadata('postgres')
connection = metadata.findConnection(connection_name)
locale = QgsSettings().value("locale/userLocale", QLocale().name())
locale = locale.split('_')[0].lower()
uri = QgsDataSourceUri(connection.uri())
uri.setTable(f'(SELECT * FROM pgmetadata.export_datasets_as_flat_table(\'{locale}\'))')
uri.setKeyColumn('uid')
layer = QgsVectorLayer(uri.uri(), '{} - {}'.format(tr("Catalog"), connection_name), 'postgres')
QgsProject.instance().addMapLayer(layer)
'''
@staticmethod
def open_external_help():
QDesktopServices.openUrl(QUrl('https://plateformesig.cenra-outils.org/'))
@staticmethod
def open_link(url):
QDesktopServices.openUrl(url)
def set_html_content(self, title=None, body=None):
""" Set the content in the dock. """
#link_logo=resources_path('icons', 'CEN_RA.png')
css_file = resources_path('css', 'dock.css')
with open(css_file, 'r', encoding='utf8') as f:
css = f.read()
html = '<html><head>'
#html += '<script src="http://ignf.github.io/geoportal-sdk/latest/dist/2d/GpSDK2D.js" defer ></script>'
html += '<style>{css}</style></head><body>'.format(css=css)
#html += '<link rel="stylesheet" href="http://ignf.github.io/geoportal-sdk/latest/dist/2d/GpSDK2D.css" >'
#html += '<script src="file:///C:/Users/tlaveille/Desktop/maps.js" defer></script>'
#html += '<noscript>Your browser does not support JavaScript!</noscript>'
if title:
html += '<h2>{title} <img class=logo src=https://i2.wp.com/www.cen-rhonealpes.fr/wp-content/uploads/2013/04/cen-rhonealpes-couleurs1.jpg?w=340&ssl=1></h2>'.format(title=title)
if body:
html += body
html += '</body></html>'
# It must be a file, even if it does not exist on the file system.
base_url = QUrl.fromLocalFile(resources_path('images', 'must_be_a_file.png'))
self.viewer.setHtml(html, base_url)
def ce_trouve_dans_psql(self,layer):
try:
uri = layer.dataProvider().uri()
except:
self.default_html_content_not_pg_layer()
self.save_button.setEnabled(False)
uri=''
if uri != '':
if not uri.table():
self.default_html_content_not_pg_layer()
self.save_button.setEnabled(False)
else:
data_count = self.sql_check(uri)
#print(data_count)
if data_count == 0:
self.default_html_content_not_metadata()
self.save_button.setEnabled(False)
else:
self.build_html_content(layer,uri)
self.save_button.setEnabled(True)
def build_html_content(self,layer,uri):
body = ''
dataall=self.sql_info(uri)
data=dataall[0]
data_url=dataall[1]
data_contact=dataall[2]
#print(len(data_url))
data_collonne=[field.name() for field in layer.dataProvider().fields()]
body += '<div><h3>Identification</h3><table class="table table-condensed">'
body += '<tr><th>Titre</th><td>{data[4]}</td></tr>'.format(data=data)
body += '<tr><th>Description</th><td>{data[5]}</td></tr>'.format(data=data)
body += '<tr><th>Categories</th><td>{data}</td></tr>'.format(data=(", ".join(str(x) for x in data[6])))
body += '<tr><th>Thèmes</th><td>{data}</td></tr>'.format(data=(", ".join(str(x) for x in data[24])))
body += '<tr><th>Mots-clés</th><td>{data[7]}</td></tr>'.format(data=data)
body += '<tr><th>Dernier mise à jour</th><td>{data[23]}</td></tr>'.format(data=data)
body += '<tr><th>Langue</th><td>{data[26]}</td></tr>'.format(data=data)
body += '</table></div>'
body += '<div><h3>Properties spatial</h3><table class="table table-condensed">'
body += '<tr><th>Niveau</th><td>{data[8]}</td></tr>'.format(data=data)
body += '<tr><th>Echelle minimum</th><td>{data[9]}</td></tr>'.format(data=data)
body += '<tr><th>Echelle maximum</th><td>{data[10]}</td></tr>'.format(data=data)
body += '<tr><th>Nombre d\'entités </th><td>{data[15]}</td></tr>'.format(data=data)
body += '<tr><th>Type de géométrie</th><td>{data[16]}</td></tr>'.format(data=data)
body += '<tr><th>Nom de projection</th><td>{data[17]}</td></tr>'.format(data=data)
body += '<tr><th>ID de projection</th><td>{data[18]}</td></tr>'.format(data=data)
body += '<tr><th>Emprise</th><td>{data[28]}</td></tr>'.format(data=data)
body += '</table></div>'
#body += '<div id="map"></div>'
body += '<div><h3>Publication</h3><table class="table table-condensed">'
body += '<tr><th>Date</th><td>{data[11]}</td></tr>'.format(data=data)
body += '<tr><th>Fréquence de mise à jour</th><td>{data[12]}</td></tr>'.format(data=data)
body += '<tr><th>Licence</th><td>{data[13]}</td></tr>'.format(data=data)
body += '<tr><th>Licence attribué</th><td>{data[25]}</td></tr>'.format(data=data)
body += '<tr><th>Restriction</th><td>{data[14]}</td></tr>'.format(data=data)
body += '</table></div>'
body += '<div><h3>Lien</h3><table class="table table-condensed table-striped table-bordered">'
body += '<tr><th>Type</th><th>URL</th><th>Type MIME</th><th>Format</th><th>Taille</th></tr>'
for value_url in data_url:
body += '<tr><td>{value_url[0]}</td><td>{value_url[1]}</td><td>{value_url[2]}</td><td>{value_url[3]}</td><td>{value_url[4]}</td></tr>'.format(value_url=value_url)
body += '</table></div>'
'''
body += '<div><h3>Liste des champs</h3><table class="table table-condensed table-striped table-bordered">'
for collonne in data_collonne:
body += '<tr><th>{collonne}</th><td>{defini}</td></tr>'.format(collonne=collonne,defini='')
body += '</table></div>'
'''
body += '<div><h3>Contacts</h3><table class="table table-condensed table-striped table-bordered">'
body += '<tr><th>Rôle</th><th>Nom</th><th>Organisation</th><th>Email</th><th>Télèphone</th></tr>'
for value_contact in data_contact:
body += '<tr><td>{value_contact[0]}</td><td>{value_contact[1]}</td><td>{value_contact[2]}</td><td>{value_contact[3]}</td><td>{value_contact[4]}</td></tr>'.format(value_contact=value_contact)
body += '</table></div>'
body += '<div><h3>Metadata</h3><table class="table table-condensed">'
body += '<tr><th>Table</th><td>{data[2]}</td></tr>'.format(data=data)
body += '<tr><th>Schema</th><td>{data[3]}</td></tr>'.format(data=data)
body += '<tr><th>Date de création</th><td>{data[20]}</td></tr>'.format(data=data)
body += '<tr><th>Date de modification</th><td>{data[21]}</td></tr>'.format(data=data)
body += '<tr><th>Encodage</th><td>{data[27]}</td></tr>'.format(data=data)
body += '<tr><th>UUID</th><td>{data[1]}</td></tr>'.format(data=data)
body += '</table></div>'
self.set_html_content(
layer.name(), body)
def default_html_content_not_pg_layer(self):
""" When it's not a PostgreSQL layer. """
self.set_html_content(
'CenRa Metadata', tr('Vous devez cliquer sur une couche dans la légende qui est stockée dans PostgreSQL.'))
def default_html_content_not_metadata(self):
self.set_html_content(
'CenRa Metadata', tr('La couche ne contien pas de métadonnée.'))
def sql_check(self,uri):
cur=login_base()
table = uri.table()
schema = uri.schema()
sql_count = """SELECT count(uid) FROM metadata.dataset
WHERE schema_name LIKE '"""+schema+"""' AND table_name LIKE '"""+table+"""';"""
cur.execute(sql_count)
data_count = cur.fetchall()
cur.close()
return data_count[0][0]
def sql_info(self,uri):
cur=login_base()
table = uri.table()
schema = uri.schema()
#[s for s in iface.activeLayer().source().split(" ") if "dbname" in s][0].split("'")[1]
sql_find = """SELECT *,right(left(st_astext(geom,2),-2),-9) FROM metadata.dataset
WHERE schema_name LIKE '"""+schema+"""' AND table_name LIKE '"""+table+"""';"""
cur.execute(sql_find)
data_general = cur.fetchall()
sql_findurl = """SELECT type,url,mime,format,taille FROM metadata.dataurl WHERE schema_name LIKE '"""+schema+"""' AND table_name LIKE '"""+table+"""';"""
cur.execute(sql_findurl)
data_url = cur.fetchall()
sql_findcontact = """SELECT role,nom,organisation,email,telephone FROM metadata.datacontact WHERE schema_name LIKE '"""+schema+"""' AND table_name LIKE '"""+table+"""';"""
cur.execute(sql_findcontact)
data_contact = cur.fetchall()
cur.close()
return data_general[0],data_url,data_contact

750
CenRa_Metabase/editor.py Normal file
View File

@ -0,0 +1,750 @@
import logging
import os
from collections import namedtuple
from enum import Enum
from functools import partial
from pathlib import Path
from xml.dom.minidom import parseString
from qgis.gui import *
from qgis.core import (
NULL,
QgsApplication,
QgsDataSourceUri,
QgsProject,
QgsProviderConnectionException,
QgsProviderRegistry,
QgsRasterLayer,
QgsSettings,
QgsVectorLayer,
QgsGeometry,
)
from qgis.PyQt.QtCore import QLocale, QUrl, QDateTime
from qgis.PyQt.QtGui import QDesktopServices, QIcon
from qgis.PyQt.QtPrintSupport import QPrinter
from qgis.PyQt.QtWebKitWidgets import QWebPage
from qgis.PyQt.QtWidgets import (
QDialog,
QAction,
QDockWidget,
QFileDialog,
QInputDialog,
QMenu,
QToolButton,
QTableWidget,
QTableWidgetItem,
)
from qgis.utils import iface
from CenRa_Metabase.resources.i18n import tr
from CenRa_Metabase.resources.resources import (
load_ui,
resources_path,
login_base,
send_issues,
)
from CenRa_Metabase.issues import CenRa_Issues
EDITOR_CLASS = load_ui('CenRa_Metabase_editorwidget_base.ui')
LOGGER = logging.getLogger('CenRa_Metabase')
class Metabase_Editor(QDialog, EDITOR_CLASS):
def __init__(self, parent=None):
_ = parent
super().__init__()
self.setupUi(self)
self.settings = QgsSettings()
self.import_xml.setAutoRaise(True)
self.import_xml.setText('')
self.import_xml.setIcon(QIcon(QgsApplication.iconPath('mActionAddHtml.svg')))
self.import_xml.clicked.connect(self.py_import_xml)
self.issues_app.setAutoRaise(True)
self.issues_app.setText('')
self.issues_app.setIcon(QIcon(QgsApplication.iconPath('mIconInfo.svg')))
self.issues_app.clicked.connect(self.issues_open)
self.categories_select_view.itemDoubleClicked.connect(self.add_categories_view)
self.categories_view.itemDoubleClicked.connect(self.deleter_categories_view)
self.themes_select_view.itemDoubleClicked.connect(self.add_themes_view)
self.themes_view.itemDoubleClicked.connect(self.deleter_themes_view)
self.annuler_button.clicked.connect(self.close)
self.ok_button.clicked.connect(self.add_metadata)
self.add_lien_button.clicked.connect(self.add_lien)
self.add_contact_button.clicked.connect(self.add_contact)
self.delete_lien_button.clicked.connect(self.delete_lien)
self.delete_contact_button.clicked.connect(self.delete_contact)
def add_metadata(self):
table_name = layer.dataProvider().uri().table()
schema_name = layer.dataProvider().uri().schema()
text_titre = self.titre_line.text()
text_description = self.description_text.toPlainText()
text_mots_cles = self.mots_cles_text.toPlainText()
text_date_maj = str(self.date_maj_date.date().toPyDate())
text_langue = self.langue_box.currentText()
row_count_categories = self.categories_view.rowCount()
row_count_themes = self.themes_view.rowCount()
row = 1
array_categories = '{'
while row_count_categories >= row:
if row_count_categories != row:
array_categories += (self.categories_view.item(row-1,0).text())+','
else:
array_categories += (self.categories_view.item(row-1,0).text())
row = row+1
array_categories += '}'
row = 1
array_themes = '{'
while row_count_themes >= row:
if row_count_themes != row:
array_themes += (self.themes_view.item(row-1,0).text())+','
else:
array_themes += (self.themes_view.item(row-1,0).text())
row = row+1
array_themes += '}'
text_date_creation = str(self.date_creation_date.date().toPyDate())
text_date_modification = str(self.date_modification_date.date().toPyDate())
text_encode = self.encodage_box.currentText()
text_extend = self.extend_plaintext.toPlainText()
int_nbr_entites = (self.nbr_layers.toPlainText())
text_geomtype = self.typegeom_plaintext.toPlainText()
text_crsname = self.crsname_plaintext.toPlainText()
text_crscode = self.crscode_plaintext.toPlainText()
text_niveau = self.niveau_plain.toPlainText()
text_echelle_min = self.echelle_min_plain.toPlainText()
text_echelle_max = self.echelle_max_plain.toPlainText()
if text_echelle_min == '':
text_echelle_min = 'NULL'
if text_echelle_max == '':
text_echelle_max = 'NULL'
text_date_publication = str(self.date_publication_date.date().toPyDate())
text_frequence = self.frequence_box.currentText()
text_restriction = self.restriction_box.currentText()
text_licence = self.licence_box.currentText()
text_licence_attrib = self.licence_attrib_box.currentText()
'''
row_count_link = self.table_lien.rowCount()
row = 1
array_link = ''
while row_count_link >= row:
if row_count_link != row:
array_link += "('"+ table_name +"','"+ schema_name +"','"+ (self.table_lien.item(row-1,1).text()) +"','"+ (self.table_lien.item(row-1,2).text()) +"','"+ (self.table_lien.item(row-1,3).text()) +"','"+ (self.table_lien.item(row-1,4).text()) +"','"+ (self.table_lien.item(row-1,5).text()) +"')"+','
else:
array_link += "('"+ table_name +"','"+ schema_name +"','"+ (self.table_lien.item(row-1,1).text()) +"','"+ (self.table_lien.item(row-1,2).text()) +"','"+ (self.table_lien.item(row-1,3).text()) +"','"+ (self.table_lien.item(row-1,4).text()) +"','"+ (self.table_lien.item(row-1,5).text()) +"')"
row = row+1
row_count_contact = self.table_contact.rowCount()
row = 1
array_contact = ''
while row_count_contact >= row:
if row_count_contact != row:
array_contact += "('"+ table_name +"','"+ schema_name +"','"+ (self.table_contact.item(row-1,1).text()) +"','"+ (self.table_contact.item(row-1,2).text()) +"','"+ (self.table_contact.item(row-1,3).text()) +"','"+ (self.table_contact.item(row-1,4).text()) +"','"+ (self.table_contact.item(row-1,5).text()) +"')"+','
else:
array_contact += "('"+ table_name +"','"+ schema_name +"','"+ (self.table_contact.item(row-1,1).text()) +"','"+ (self.table_contact.item(row-1,2).text()) +"','"+ (self.table_contact.item(row-1,3).text()) +"','"+ (self.table_contact.item(row-1,4).text()) +"','"+ (self.table_contact.item(row-1,5).text()) +"')"
row = row+1
'''
exist=self.status_metadata(layer)
cur_con=login_base(take=True)
cur=cur_con[0]
con=cur_con[1]
list_champs_sql = ''
values_sql_add = ''
if exist:
SQL_uid = """SELECT uid from metadata.dataset where table_name like '"""+table_name+"""' and schema_name like '"""+schema_name+"""';"""
cur.execute(SQL_uid)
text_uid = (cur.fetchall())[0][0]
SQL_delete = """DELETE from metadata.dataset where table_name like '"""+table_name+"""' and schema_name like '"""+schema_name+"""';"""
cur.execute(SQL_delete)
values_sql_add += "'"+text_uid+"',"
list_champs_sql+='uid,'
global uid_delete_list_link,uid_delete_list_contact
if len(uid_delete_list_link) >= 35:
SQL_delete_link = """DELETE FROM metadata.dataurl WHERE uid IN ("""+ uid_delete_list_link[:-1] +""");"""
cur.execute(SQL_delete_link)
uid_delete_list_link = ''
if len(uid_delete_list_contact) >= 35:
SQL_delete_contact = """DELETE FROM metadata.datacontact WHERE uid IN ("""+ uid_delete_list_contact[:-1] +""");"""
cur.execute(SQL_delete_contact)
uid_delete_list_contact=''
list_champs_sql += 'table_name,schema_name,title,abstract,keywords,data_last_update,langue,categories,themes,creation_date,update_date,encode,geom,spatial_extent,feature_count,geometry_type,projection_name,projection_authid,spatial_level,minimum_optimal_scale,maximum_optimal_scale,publication_date,publication_frequency,confidentiality,license,license_attribution'
values_sql_add += "'"+table_name+"','"+schema_name+"','"+text_titre+"','"+text_description+"','"+text_mots_cles+"','"+text_date_maj+"','"+text_langue+"','"+array_categories+"','"+array_themes+"','"+text_date_creation+"','"+text_date_modification+"','"+text_encode+"','"+text_extend+"','"+text_extend+"','"+int_nbr_entites+"','"+text_geomtype+"','"+text_crsname+"','"+text_crscode+"','"+text_niveau+"',"+text_echelle_min+","+text_echelle_max+",'"+text_date_publication+"','"+text_frequence+"','"+text_restriction+"','"+text_licence+"','"+text_licence_attrib+"'"
SQL_add = """INSERT INTO metadata.dataset ("""+list_champs_sql+""") VALUES ("""+values_sql_add+""");"""
cur.execute(SQL_add)
global array_link,array_contact
if len(array_link) >= 25:
array_link=array_link[:-1]
SQL_add_link = """INSERT INTO metadata.dataurl (table_name,schema_name,type,url,mime,format,taille) VALUES """+array_link+""";"""
cur.execute(SQL_add_link)
array_link = ''
if len(array_contact) >= 25:
array_contact=array_contact[0:-1]
SQL_add_contact = """INSERT INTO metadata.datacontact (table_name,schema_name,role,nom,organisation,email,telephone) VALUES """+array_contact+""";"""
cur.execute(SQL_add_contact)
array_contact = ''
con.commit()
cur.close()
self.close()
iface.layerTreeView().setCurrentLayer(None)
iface.layerTreeView().setCurrentLayer(layer)
def raise_(self):
global layer
layer = iface.activeLayer()
global uid_delete_list_link,uid_delete_list_contact,array_link,array_contact
uid_delete_list_link=''
uid_delete_list_contact=''
array_link = ''
array_contact = ''
is_ok=self.is_in_psql(layer)
if is_ok:
exist=self.status_metadata(layer)
if exist:
self.reload_data(layer)
else:
self.new_data(layer)
else:
self.close()
iface.messageBar().pushMessage("Information :", "Cette couche n'est pas stockée dans PostgreSQL", level=Qgis.Warning, duration=30)
def is_in_psql(self,layer):
try:
uri = layer.dataProvider().uri()
except:
uri=''
return False
if uri != '':
if not uri.table():
return False
else:
return True
def status_metadata(self,layer):
uri = layer.dataProvider().uri()
table = uri.table()
schema = uri.schema()
cur=login_base()
count_sql = """ SELECT count(uid) FROM metadata.dataset WHERE table_name LIKE '"""+table+"""' AND schema_name LIKE '"""+schema+"""';"""
cur.execute(count_sql)
data_count = (cur.fetchall())[0][0]
if data_count == 1:
return True
else:
return False
cur.close()
def new_data(self,layer):
#print(layer.name(),'is new data')
reloader=False
self.interface_view(layer,reloader)
def reload_data(self,layer):
#print(layer.name(),'reload data')
reloader=True
self.interface_view(layer,reloader)
def interface_view(self,layer,reloader):
self.description_text.setText(None)
self.mots_cles_text.setText(None)
self.uuid_ligne.setText(None)
self.niveau_plain.setPlainText(None)
self.echelle_min_plain.setPlainText(None)
self.echelle_max_plain.setPlainText(None)
self.url_line.setText(None)
self.taille_line.setText(None)
self.nom_line.setText(None)
self.email_line.setText(None)
self.telephone_line.setText(None)
self.encodage_box.clear()
self.frequence_box.clear()
self.licence_box.clear()
self.licence_attrib_box.clear()
self.restriction_box.clear()
all_list=self.fletch_ref()
categories_list=all_list[0]
themes_list=all_list[1]
langue_list=all_list[2]
encodage_list=all_list[3]
frequency_list=all_list[4]
confidentiality_list=all_list[5]
license_list=all_list[6]
type_list=all_list[7]
mime_list=all_list[8]
format_list=all_list[9]
role_list=all_list[10]
organisation_list=all_list[11]
#langue_box
self.langue_box.clear()
self.langue_box.addItem('')
#self.langue_box.addItem('Fr')
#self.langue_box.addItem('En')
for langue_list_data in langue_list:
self.langue_box.addItem(langue_list_data[0])
for encodage_list_data in encodage_list:
self.encodage_box.addItem(encodage_list_data[0])
self.table_ligne.setText(layer.dataProvider().uri().table())
self.schema_ligne.setText(layer.dataProvider().uri().schema())
#categories_select_view
self.categories_select_view.setColumnCount(1)
self.categories_select_view.setColumnWidth(0, 230)
self.categories_select_view.setHorizontalHeaderLabels(['List des categories'])
#categories_view
self.categories_view.setRowCount(0)
self.categories_view.setColumnCount(1)
self.categories_view.setColumnWidth(0, 230)
self.categories_view.setHorizontalHeaderLabels(['Categories'])
#themes_select_view
self.themes_select_view.setColumnCount(1)
self.themes_select_view.setColumnWidth(0, 230)
self.themes_select_view.setHorizontalHeaderLabels(['List des thèmes'])
#themes_view
self.themes_view.setRowCount(0)
self.themes_view.setColumnCount(1)
self.themes_view.setColumnWidth(0, 230)
self.themes_view.setHorizontalHeaderLabels(['Thèmes'])
#lien_view
self.table_lien.setRowCount(0)
self.table_lien.setColumnCount(6)
self.table_lien.setColumnWidth(0, 0)
self.table_lien.setHorizontalHeaderLabels(['','Type','URL','MIME','Format','Taille'])
#contact_view
self.table_contact.setRowCount(0)
self.table_contact.setColumnCount(6)
self.table_contact.setColumnWidth(0, 0)
self.table_contact.setHorizontalHeaderLabels(['','Rôle','Nom','Organisation','Email','Telephone'])
#print(self.date_maj_date.date().toPyDate())
vector_extend = layer.extent()
polygone_extend = QgsGeometry.fromRect(vector_extend).asWkt()
self.extend_plaintext.setPlainText(str(polygone_extend))
qgstype = str(layer.type())[10:]
if qgstype != 'Raster' :
count_layers = str(layer.featureCount())
geomtype = str(layer.wkbType())[8:]
elif qgstype == 'Raster':
count_layers = str(layer.dataProvider().bandCount())
geomtype = qgstype
self.nbr_layers.setPlainText(count_layers)
self.typegeom_plaintext.setPlainText(geomtype)
crs_name = str(layer.crs().description())
self.crsname_plaintext.setPlainText(crs_name)
crs_code = str(layer.crs().authid())
self.crscode_plaintext.setPlainText(crs_code)
self.frequence_box.addItem('')
self.restriction_box.addItem('')
self.licence_box.addItem('')
self.licence_attrib_box.addItem('')
for frequency_list_data in frequency_list:
self.frequence_box.addItem(frequency_list_data[0])
for confidentiality_list_data in confidentiality_list:
self.restriction_box.addItem(confidentiality_list_data[0])
for license_list_data in license_list:
self.licence_box.addItem(license_list_data[0])
self.type_box.clear()
self.mime_box.clear()
self.format_box.clear()
self.role_box.clear()
self.organisation_box.clear()
self.type_box.addItem('')
self.mime_box.addItem('')
self.format_box.addItem('')
self.role_box.addItem('')
self.organisation_box.addItem('')
for type_list_data in type_list:
self.type_box.addItem(type_list_data[0])
for mime_list_data in mime_list:
self.mime_box.addItem(mime_list_data[0])
for format_list_data in format_list:
self.format_box.addItem(format_list_data[0])
for role_list_data in role_list:
self.role_box.addItem(role_list_data[0])
for organisation_list_data in organisation_list:
self.organisation_box.addItem(organisation_list_data[0])
if reloader:
sql_dataload=self.sql_info(layer.dataProvider().uri())
sql_contactlink=self.sql_infoother(layer.dataProvider().uri())
sql_datalink=sql_contactlink[0]
sql_datacontact=sql_contactlink[1]
#print(sql_dataload)
self.titre_line.setText(sql_dataload[4])
self.date_maj_date.setDateTime(sql_dataload[23])
self.date_publication_date.setDateTime(sql_dataload[11])
self.description_text.setText(sql_dataload[5])
self.mots_cles_text.setText(sql_dataload[7])
array_langue_box = [self.langue_box.itemText(i) for i in range(self.langue_box.count())]
self.langue_box.setCurrentIndex(array_langue_box.index(sql_dataload[26]))
self.uuid_ligne.setText(sql_dataload[1])
self.categories_view.setRowCount(len(sql_dataload[6]))
i=0
for categorie_data in sql_dataload[6]:
self.categories_view.setItem(i,0,QTableWidgetItem(categorie_data))
i=i+1
self.themes_view.setRowCount(len(sql_dataload[24]))
i=0
for themes_data in sql_dataload[24]:
self.themes_view.setItem(i,0,QTableWidgetItem(themes_data))
i=i+1
self.categories_select_view.setRowCount(len(categories_list)-len(sql_dataload[6]))
self.themes_select_view.setRowCount(len(themes_list)-len(sql_dataload[24]))
i=0
for categorie_select_data in categories_list:
try:
in_index = sql_dataload[6].index(categorie_select_data[0])
in_index=False
except:
in_index=True
if in_index:
self.categories_select_view.setItem(i,0,QTableWidgetItem(categorie_select_data[0]))
i=i+1
i=0
for themes_select_data in themes_list:
try:
in_index = sql_dataload[24].index(themes_select_data[0])
in_index=False
except:
in_index=True
if in_index:
self.themes_select_view.setItem(i,0,QTableWidgetItem(themes_select_data[0]))
i=i+1
array_encodage_box = [self.encodage_box.itemText(i) for i in range(self.encodage_box.count())]
self.encodage_box.setCurrentIndex(array_encodage_box.index(sql_dataload[27]))
self.niveau_plain.setPlainText(sql_dataload[8])
if str(sql_dataload[9]) == 'None':
value_echelle_min = ''
else:
value_echelle_min = str(sql_dataload[9])
if str(sql_dataload[10]) == 'None':
value_echelle_max = ''
else:
value_echelle_max = str(sql_dataload[10])
self.echelle_min_plain.setPlainText(value_echelle_min)
self.echelle_max_plain.setPlainText(value_echelle_max)
array_frequence_box = [self.frequence_box.itemText(i) for i in range(self.frequence_box.count())]
self.frequence_box.setCurrentIndex(array_frequence_box.index(sql_dataload[12]))
array_licence_box = [self.licence_box.itemText(i) for i in range(self.licence_box.count())]
self.licence_box.setCurrentIndex(array_licence_box.index(sql_dataload[13]))
array_confidentiality_box = [self.restriction_box.itemText(i) for i in range(self.restriction_box.count())]
self.restriction_box.setCurrentIndex(array_confidentiality_box.index(sql_dataload[14]))
array_licence_attrib_box = [self.licence_attrib_box.itemText(i) for i in range(self.licence_attrib_box.count())]
self.licence_attrib_box.setCurrentIndex(array_licence_attrib_box.index(sql_dataload[25]))
c=0
#self.table_lien.setRowCount(len(sql_datalink))
for lien_data in sql_datalink:
self.table_lien.insertRow(c)
self.table_lien.setItem(c,0,QTableWidgetItem(lien_data[1]))
self.table_lien.setItem(c,1,QTableWidgetItem(lien_data[4]))
self.table_lien.setItem(c,2,QTableWidgetItem(lien_data[5]))
self.table_lien.setItem(c,3,QTableWidgetItem(lien_data[6]))
self.table_lien.setItem(c,4,QTableWidgetItem(lien_data[7]))
self.table_lien.setItem(c,5,QTableWidgetItem(lien_data[8]))
c=c+1
c=0
#self.table_contact.setRowCount(len(sql_datacontact))
for contact_data in sql_datacontact:
self.table_contact.insertRow(c)
self.table_contact.setItem(c,0,QTableWidgetItem(contact_data[1]))
self.table_contact.setItem(c,1,QTableWidgetItem(contact_data[4]))
self.table_contact.setItem(c,2,QTableWidgetItem(contact_data[5]))
self.table_contact.setItem(c,3,QTableWidgetItem(contact_data[6]))
self.table_contact.setItem(c,4,QTableWidgetItem(contact_data[7]))
self.table_contact.setItem(c,5,QTableWidgetItem(contact_data[8]))
c=c+1
else:
#titre_line
self.titre_line.setText(layer.name())
self.langue_box.setCurrentIndex(1)
#date_maj_date
now = QtCore.QDateTime.currentDateTime()
self.date_maj_date.setDateTime(now)
self.date_creation_date.setDateTime(now)
self.date_modification_date.setDateTime(now)
self.date_publication_date.setDateTime(now)
self.categories_select_view.setRowCount(len(categories_list))
self.themes_select_view.setRowCount(len(themes_list))
i=0
for categorie_select_data in categories_list:
self.categories_select_view.setItem(i,0,QTableWidgetItem(categorie_select_data[0]))
i=i+1
i=0
for themes_select_data in themes_list:
self.themes_select_view.setItem(i,0,QTableWidgetItem(themes_select_data[0]))
i=i+1
#print(self.langue_box.currentText())
def sql_info(self,uri):
cur=login_base()
table = uri.table()
schema = uri.schema()
#[s for s in iface.activeLayer().source().split(" ") if "dbname" in s][0].split("'")[1]
sql_find = """SELECT *,right(left(st_astext(geom,2),-2),-9) FROM metadata.dataset
WHERE schema_name LIKE '"""+schema+"""' AND table_name LIKE '"""+table+"""';"""
cur.execute(sql_find)
data_general = cur.fetchall()
cur.close()
return data_general[0]
def sql_infoother(self,uri):
cur=login_base()
table = uri.table()
schema = uri.schema()
sql_findlink = """SELECT * FROM metadata.dataurl
WHERE schema_name LIKE '"""+schema+"""' AND table_name LIKE '"""+table+"""';"""
cur.execute(sql_findlink)
data_link = cur.fetchall()
sql_findcontact = """SELECT * FROM metadata.datacontact
WHERE schema_name LIKE '"""+schema+"""' AND table_name LIKE '"""+table+"""';"""
cur.execute(sql_findcontact)
data_contact = cur.fetchall()
cur.close()
return data_link,data_contact
def add_categories_view(self):
values_add_categories = self.categories_select_view.selectedItems()[0].text()
self.categories_select_view.removeRow(self.categories_select_view.currentRow())
self.categories_view.insertRow(0)
self.categories_view.setItem(0,0,QTableWidgetItem(values_add_categories))
def deleter_categories_view(self):
values_deleter_categories = self.categories_view.selectedItems()[0].text()
self.categories_view.removeRow(self.categories_view.currentRow())
self.categories_select_view.insertRow(0)
self.categories_select_view.setItem(0,0,QTableWidgetItem(values_deleter_categories))
def add_themes_view(self):
values_add_themes = self.themes_select_view.selectedItems()[0].text()
self.themes_select_view.removeRow(self.themes_select_view.currentRow())
self.themes_view.insertRow(0)
self.themes_view.setItem(0,0,QTableWidgetItem(values_add_themes))
def deleter_themes_view(self):
values_deleter_themes = self.themes_view.selectedItems()[0].text()
self.themes_view.removeRow(self.themes_view.currentRow())
self.themes_select_view.insertRow(0)
self.themes_select_view.setItem(0,0,QTableWidgetItem(values_deleter_themes))
def add_lien(self):
cur=login_base()
maxrow=self.table_lien.rowCount()
self.table_lien.insertRow(maxrow)
table = layer.dataProvider().uri().table()
schema = layer.dataProvider().uri().schema()
if self.taille_line.text() == '':
sql_sizefile = """SELECT pg_size_pretty(pg_total_relation_size('"""+schema+'.'+table+"""'));"""
try:
cur.execute(sql_sizefile)
boolean = True
except:
boolean = False
if boolean == True:
size_file = (cur.fetchall())[0][0]
else:
size_file = ''
else:
size_file = self.taille_line.text()
self.table_lien.setItem(maxrow,0,QTableWidgetItem('new_value'))
self.table_lien.setItem(maxrow,1,QTableWidgetItem(self.type_box.currentText()))
self.table_lien.setItem(maxrow,2,QTableWidgetItem(self.url_line.text()))
self.table_lien.setItem(maxrow,3,QTableWidgetItem(self.mime_box.currentText()))
self.table_lien.setItem(maxrow,4,QTableWidgetItem(self.format_box.currentText()))
self.table_lien.setItem(maxrow,5,QTableWidgetItem(str(size_file)))
global array_link
array_link += "('"+ table +"','"+ schema +"','"+ self.type_box.currentText() +"','"+ self.url_line.text() +"','"+ self.mime_box.currentText() +"','"+ self.format_box.currentText() +"','"+ size_file +"'),"
cur.close()
def add_contact(self):
maxrow=self.table_contact.rowCount()
self.table_contact.insertRow(maxrow)
self.table_contact.setItem(maxrow,0,QTableWidgetItem('new_value'))
self.table_contact.setItem(maxrow,1,QTableWidgetItem(self.role_box.currentText()))
self.table_contact.setItem(maxrow,2,QTableWidgetItem(self.nom_line.text()))
self.table_contact.setItem(maxrow,3,QTableWidgetItem(self.organisation_box.currentText()))
self.table_contact.setItem(maxrow,4,QTableWidgetItem(self.email_line.text()))
self.table_contact.setItem(maxrow,5,QTableWidgetItem(self.telephone_line.text()))
table = layer.dataProvider().uri().table()
schema = layer.dataProvider().uri().schema()
global array_contact
array_contact += "('"+ table +"','"+ schema +"','"+ self.role_box.currentText() +"','"+ self.nom_line.text() +"','"+ self.organisation_box.currentText() +"','"+ self.email_line.text() +"','"+ self.telephone_line.text() +"'),"
def delete_lien(self):
global uid_delete_list_link,array_link
lien_uid = self.table_lien.item(self.table_lien.currentRow(),0).text()
self.table_lien.removeRow(self.table_lien.currentRow())
if lien_uid == 'new_value':
position = self.table_lien.currentRow()
if position < 0:
position=position+1
run_x = 0
while position >= run_x:
#print(position,run_x)
if run_x == 0:
debut = array_link.find("(")
else:
debut = array_link.find("(",fin+1)
fin = array_link.find(")",debut)
#print(debut,fin)
if run_x == 50:
break
run_x+=1
#print(array_link[fin+1:])
if debut <= 0:
debut = 1
fin+= 1
array_link = array_link[:debut-1]+array_link[fin+1:]
#print('a:',array_link)
else:
uid_delete_list_link += "'"+lien_uid+"',"
def delete_contact(self):
global uid_delete_list_contact,array_contact
contact_uid = self.table_contact.item(self.table_contact.currentRow(),0).text()
self.table_contact.removeRow(self.table_contact.currentRow())
if contact_uid == 'new_value':
position = self.table_contact.currentRow()
if position < 0:
position=position+1
#print('p:',position)
run_x = 0
while position >= run_x:
if run_x == 0:
debut = array_contact.find("(")
else:
debut = array_contact.find("(",fin+1)
fin = array_contact.find(")",debut)
#print(debut,fin)
if run_x == 50:
break
run_x+=1
#print(array_contact[fin+1:])
if debut <= 0:
debut = 1
fin+= 1
array_contact = array_contact[:debut-1]+array_contact[fin+1:]
#print('a:',array_contact)
else:
uid_delete_list_contact += "'"+contact_uid+"',"
def fletch_ref(self):
cur=login_base()
SQL_categories="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'dataset.categories' ORDER BY code,item_order;"""
SQL_themes="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'dataset.themes' ORDER BY label_fr;"""
SQL_langue="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'dataset.langue';"""
SQL_encodage="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'dataset.encodage';"""
SQL_frequency="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'dataset.publication_frequency' ORDER BY label_fr;"""
SQL_confidentiality="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'dataset.confidentiality' ORDER BY label_fr;"""
SQL_license="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'dataset.license' ORDER BY label_fr;"""
SQL_type="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'link.type' ORDER BY label_fr;"""
SQL_mime="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'link.mime' ORDER BY label_fr;"""
SQL_format="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'link.format' ORDER BY label_fr;"""
SQL_role="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'contact.contact_role' ORDER BY label_fr;"""
SQL_organisation="""SELECT label_fr FROM metadata.glossary WHERE field LIKE 'contact.organisation' ORDER BY label_fr;"""
cur.execute(SQL_categories)
categories_list=cur.fetchall()
cur.execute(SQL_themes)
themes_list=cur.fetchall()
cur.execute(SQL_langue)
langue_list=cur.fetchall()
cur.execute(SQL_encodage)
encodage_list=cur.fetchall()
cur.execute(SQL_frequency)
frequency_list=cur.fetchall()
cur.execute(SQL_confidentiality)
confidentiality_list=cur.fetchall()
cur.execute(SQL_license)
license_list=cur.fetchall()
cur.execute(SQL_type)
type_list=cur.fetchall()
cur.execute(SQL_mime)
mime_list=cur.fetchall()
cur.execute(SQL_format)
format_list=cur.fetchall()
cur.execute(SQL_role)
role_list=cur.fetchall()
cur.execute(SQL_organisation)
organisation_list=cur.fetchall()
return categories_list,themes_list,langue_list,encodage_list,frequency_list,confidentiality_list,license_list,type_list,mime_list,format_list,role_list,organisation_list
cur.close()
def py_import_xml(self):
folder = QFileDialog.getOpenFileName()
if folder:
folder=folder[0]
if folder[len(folder)-4:] == '.xml' :
print('is .xml')
def issues_open(self):
self.issues = CenRa_Issues()
self.issues.show()

BIN
CenRa_Metabase/icon.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB