776 lines
34 KiB
Python
776 lines
34 KiB
Python
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 (
|
|
QgsApplication,
|
|
QgsSettings,
|
|
QgsGeometry,
|
|
QgsWkbTypes,
|
|
Qgis,
|
|
)
|
|
from qgis.PyQt import QtGui, QtCore
|
|
from qgis.PyQt.QtGui import QIcon
|
|
# from qgis.PyQt.QtPrintSupport import QPrinter
|
|
# from qgis.PyQt.QtWebKitWidgets import QWebPage
|
|
import psycopg2
|
|
from qgis.PyQt.QtWidgets import (
|
|
QDialog,
|
|
QFileDialog,
|
|
QTableWidgetItem,
|
|
)
|
|
from qgis.utils import iface
|
|
|
|
try:
|
|
from .tools.PythonSQL import login_base
|
|
except ValueError:
|
|
print('Pas de fichier PythonSQL')
|
|
|
|
from .tools.resources import (
|
|
load_ui,
|
|
resources_path,
|
|
# send_issues,
|
|
)
|
|
# from .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.setWindowIcon(QtGui.QIcon(resources_path('icons', 'icon.png')))
|
|
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.auto_adding.setIcon(QtGui.QIcon(resources_path('icons', 'auto_add.png')))
|
|
self.auto_adding.hide()
|
|
if os.getlogin() == 'tlaveille' or 'lpoulin' or 'rclement':
|
|
self.auto_adding.show()
|
|
|
|
self.auto_adding.clicked.connect(self.auto_run)
|
|
# 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 auto_run(self):
|
|
self.role_box.setCurrentIndex(1)
|
|
self.nom_line.setText('LAVEILLE')
|
|
self.organisation_box.setCurrentIndex(1)
|
|
self.email_line.setText('tom.laveille@cen-rhonealpes.fr')
|
|
self.telephone_line.setText('0451260811')
|
|
self.add_contact()
|
|
|
|
self.type_box.setCurrentIndex(16)
|
|
self.url_line.setText('www.cen-rhonealpes.fr')
|
|
self.mime_box.setCurrentIndex(16)
|
|
self.format_box.setCurrentIndex(0)
|
|
self.taille_line.setText('45')
|
|
self.add_lien()
|
|
|
|
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):
|
|
self.activateWindow()
|
|
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 AttributeError:
|
|
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 = QgsWkbTypes.displayString(layer.wkbType())
|
|
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 ValueError:
|
|
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 ValueError:
|
|
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 psycopg2.errors.UndefinedTable:
|
|
boolean = False
|
|
|
|
if boolean is 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):
|
|
fin = ''
|
|
global uid_delete_list_link, array_link
|
|
try:
|
|
lien_uid = self.table_lien.item(self.table_lien.currentRow(), 0).text()
|
|
except AttributeError:
|
|
lien_uid = True
|
|
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)
|
|
elif lien_uid is True:
|
|
print('Pas de ligne "Lien"')
|
|
else:
|
|
uid_delete_list_link += "'" + lien_uid + "',"
|
|
|
|
def delete_contact(self):
|
|
fin = ''
|
|
global uid_delete_list_contact, array_contact
|
|
try:
|
|
contact_uid = self.table_contact.item(self.table_contact.currentRow(), 0).text()
|
|
except AttributeError:
|
|
contact_uid = True
|
|
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)
|
|
elif contact_uid is True:
|
|
print('Pas de ligne "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()
|