class pyArchInitDialog_Config(QDialog, Ui_Dialog_Config):
if os.name == 'posix':
HOME = os.environ['HOME']
elif os.name == 'nt':
HOME = os.environ['HOMEPATH']
PARAMS_DICT = {
'SERVER': '',
'HOST': '',
'DATABASE': '',
'PASSWORD': '',
'PORT': '',
'USER': '',
'THUMB_PATH': '',
'EXPERIMENTAL': ''
}
def __init__(self, parent=None, db=None):
QDialog.__init__(self, parent)
# Set up the user interface from Designer.
self.setupUi(self)
self.load_dict()
self.charge_data()
self.connect(self.comboBox_Database,
SIGNAL("editTextChanged (const QString&)"),
self.set_db_parameter)
self.connect(self.comboBox_server_rd,
SIGNAL("editTextChanged (const QString&)"),
self.set_db_import_from_parameter)
self.connect(self.comboBox_server_wt,
SIGNAL("editTextChanged (const QString&)"),
self.set_db_import_to_parameter)
self.connect(self.comboBox_experimental,
SIGNAL("editTextChanged (const QString&)"), self.message)
def set_db_parameter(self):
if str(self.comboBox_Database.currentText()) == 'postgres':
self.lineEdit_DBname.setText("pyarchinit")
self.lineEdit_Host.setText('127.0.0.1')
self.lineEdit_Port.setText('5432')
self.lineEdit_User.setText('postgres')
if str(self.comboBox_Database.currentText()) == 'sqlite':
self.lineEdit_DBname.setText("pyarchinit_db.sqlite")
self.lineEdit_Host.setText('')
self.lineEdit_Password.setText('')
self.lineEdit_Port.setText('')
self.lineEdit_User.setText('')
def set_db_import_from_parameter(self):
QMessageBox.warning(self, "ok", "entrato in read.", QMessageBox.Ok)
if str(self.comboBox_server_rd.currentText()) == 'postgres':
QMessageBox.warning(self, "ok", "entrato in if", QMessageBox.Ok)
self.lineEdit_host_rd.setText('127.0.0.1')
self.lineEdit_username_rd.setText('postgres')
self.lineEdit_database_rd.setText('pyarchinit')
self.lineEdit_port_rd.setText('5432')
if str(self.comboBox_server_rd.currentText()) == 'sqlite':
QMessageBox.warning(self, "ok", "entrato in if", QMessageBox.Ok)
self.lineEdit_host_rd.setText.setText('')
self.lineEdit_username_rd.setText('')
self.lineEdit_lineEdit_pass_rd.setText('')
self.lineEdit_database_rd.setText('pyarchinit_db.sqlite')
self.lineEdit_port_rd.setText('')
def set_db_import_to_parameter(self):
QMessageBox.warning(self, "ok", "entrato in write", QMessageBox.Ok)
if str(self.comboBox_server_wt.currentText()) == 'postgres':
QMessageBox.warning(self, "ok", "entrato in if", QMessageBox.Ok)
self.lineEdit_host_wt.setText('127.0.0.1')
self.lineEdit_username_wt.setText('postgres')
self.lineEdit_database_wt.setText('pyarchinit')
self.lineEdit_port_wt.setText('5432')
if str(self.comboBox_server_wt.currentText()) == 'sqlite':
QMessageBox.warning(self, "ok", "entrato in if", QMessageBox.Ok)
self.lineEdit_host_wt.setText.setText('')
self.lineEdit_username_wt.setText('')
self.lineEdit_lineEdit_pass_wt.setText('')
self.lineEdit_database_wt.setText('pyarchinit_db.sqlite')
self.lineEdit_port_wt.setText('')
def load_dict(self):
path_rel = os.path.join(os.sep, str(self.HOME), 'pyarchinit_DB_folder',
'config.cfg')
conf = open(path_rel, "r")
data = conf.read()
self.PARAMS_DICT = ast.literal_eval(data)
def save_dict(self):
#save data into config.cfg file
path_rel = os.path.join(os.sep, str(self.HOME), 'pyarchinit_DB_folder',
'config.cfg')
f = open(path_rel, "w")
f.write(str(self.PARAMS_DICT))
f.close()
def message(self):
QMessageBox.warning(
self, "ok",
"Per rendere effettive le modifiche e' necessario riavviare Qgis. Grazie.",
QMessageBox.Ok)
self.on_pushButton_save_pressed()
def on_pushButton_save_pressed(self):
self.PARAMS_DICT['SERVER'] = str(self.comboBox_Database.currentText())
self.PARAMS_DICT['HOST'] = str(self.lineEdit_Host.text())
self.PARAMS_DICT['DATABASE'] = str(self.lineEdit_DBname.text())
self.PARAMS_DICT['PASSWORD'] = str(self.lineEdit_Password.text())
self.PARAMS_DICT['PORT'] = str(self.lineEdit_Port.text())
self.PARAMS_DICT['USER'] = str(self.lineEdit_User.text())
self.PARAMS_DICT['THUMB_PATH'] = str(self.lineEdit_Thumb_path.text())
self.PARAMS_DICT['EXPERIMENTAL'] = str(
self.comboBox_experimental.currentText())
self.save_dict()
self.try_connection()
def on_pushButton_crea_database_pressed(self):
import time
try:
db = os.popen(
"createdb -U postgres -p %s -h localhost -E UTF8 -T %s -e %s"
% (str(self.lineEdit_port_db.text()),
str(self.lineEdit_template_postgis.text()),
str(self.lineEdit_dbname.text())))
barra = self.pyarchinit_progressBar_db
barra.setMinimum(0)
barra.setMaximum(9)
for a in range(10):
time.sleep(1)
barra.setValue(a)
QMessageBox.warning(self, "ok",
"Installazione avvenuta con successo",
QMessageBox.Ok)
except Exception as e:
QMessageBox.warning(self, "opss", "qualcosa non va" + str(e),
QMessageBox.Ok)
def on_pushButton_crea_layer_pressed(self):
import time
if os.name == 'posix':
home = os.environ['HOME']
elif os.name == 'nt':
home = os.environ['HOMEPATH']
try:
module_path_rel = os.path.join(os.sep, '.qgis2', 'python',
'plugins', 'pyarchinit', 'modules',
'utility', 'DBfiles',
'pyarchinit_postgis15_empty.dump')
module_path = ('%s%s') % (home, module_path_rel)
postgis15 = os.popen(
"pg_restore --host localhost --port %s --username postgres --dbname %s --role postgres --no-password --verbose %s"
% (str(self.lineEdit_port_db.text()),
str(self.lineEdit_dbname.text()), str(module_path)))
barra2 = self.pyarchinit_progressBar_template
barra2.setMinimum(0)
barra2.setMaximum(9)
for a in range(10):
time.sleep(1)
barra2.setValue(a)
QMessageBox.warning(self, "ok",
"Installazione avvenuta con successo",
QMessageBox.Ok)
except Exception as e:
QMessageBox.warning(self, "opss", "qualcosa non va" + str(e),
QMessageBox.Ok)
def on_pushButton_crea_layer_2_pressed(self):
from pyarchinit_OS_utility import *
import time
if os.name == 'posix':
home = os.environ['HOME']
elif os.name == 'nt':
home = os.environ['HOMEPATH']
try:
module_path_rel = os.path.join(os.sep, '.qgis2', 'python',
'plugins', 'pyarchinit', 'modules',
'utility', 'DBfiles',
'pyarchinit_postgis20_empty.dump')
module_path = ('%s%s') % (home, module_path_rel)
postgis15 = os.popen(
"pg_restore --host localhost --port %s --username postgres --dbname %s --role postgres --no-password --verbose %s"
% (str(self.lineEdit_port_db.text()),
str(self.lineEdit_dbname.text()), str(module_path)))
barra2 = self.pyarchinit_progressBar_template
barra2.setMinimum(0)
barra2.setMaximum(9)
for a in range(10):
time.sleep(1)
barra2.setValue(a)
QMessageBox.warning(self, "ok",
"Installazione avvenuta con successo",
QMessageBox.Ok)
except Exception as e:
QMessageBox.warning(self, "opss", "qualcosa non va" + str(e),
QMessageBox.Ok)
def on_pushButton_crea_db_sqlite_pressed(self):
try:
from pyarchinit_conn_strings import *
conn = Connection()
conn_str = conn.conn_str()
from pyarchinit_db_manager import *
self.DB_MANAGER = Pyarchinit_db_management(conn_str)
self.DB_MANAGER.connection()
self.DB_MANAGER.execute_sql_create_spatialite_db()
except:
QMessageBox.warning(
self, "Alert",
"L'installazione e' fallita. Riavvia Qgis. Se l'errore persiste verifica che i layer non siano gia' installati oppure sia stia usando un db Postgres",
QMessageBox.Ok)
else:
QMessageBox.warning(self, "Alert",
"L'installazione ha avuto successo!",
QMessageBox.Ok)
def try_connection(self):
from pyarchinit_conn_strings import *
conn = Connection()
conn_str = conn.conn_str()
from pyarchinit_db_manager import *
self.DB_MANAGER = Pyarchinit_db_management(
conn_str
) #sqlite:///\Users\Windows\pyarchinit_DB_folder\pyarchinit_db.sqlite
test = self.DB_MANAGER.connection()
test = str(test)
if test == "":
QMessageBox.warning(self, "Messaggio",
"Connessione avvenuta con successo",
QMessageBox.Ok)
elif test.find("create_engine") != -1:
QMessageBox.warning(
self, "Alert",
"Verifica i parametri di connessione. <br> Se sono corretti RIAVVIA QGIS",
QMessageBox.Ok)
else:
QMessageBox.warning(
self, "Alert", "Errore di connessione: <br>" + str(test) +
"<br> Cambia i parametri e riprova a connetterti. Se cambi server (Postgres o Sqlite) ricordati di cliccare su connetti e RIAVVIARE Qgis",
QMessageBox.Ok)
def charge_data(self):
#load data from config.cfg file
#print self.PARAMS_DICT
self.comboBox_Database.setEditText(self.PARAMS_DICT['SERVER'])
self.lineEdit_Host.setText(self.PARAMS_DICT['HOST'])
self.lineEdit_DBname.setText(self.PARAMS_DICT['DATABASE'])
self.lineEdit_Password.setText(self.PARAMS_DICT['PASSWORD'])
self.lineEdit_Port.setText(self.PARAMS_DICT['PORT'])
self.lineEdit_User.setText(self.PARAMS_DICT['USER'])
self.lineEdit_Thumb_path.setText(self.PARAMS_DICT['THUMB_PATH'])
try:
self.comboBox_experimental.setEditText(
self.PARAMS_DICT['EXPERIMENTAL'])
except:
self.comboBox_experimental.setEditText("No")
###############
def test_def(self):
pass
def on_pushButton_import_pressed(self):
id_table_class_mapper_conv_dict = {
'US': 'id_us',
'UT': 'id_ut',
'SITE': 'id_sito',
'PERIODIZZAZIONE': 'id_perfas',
'INVENTARIO_MATERIALI': 'id_invmat',
'STRUTTURA': 'id_struttura',
'TAFONOMIA': 'id_tafonomia',
'SCHEDAIND': 'id_scheda_ind',
'CAMPIONE': 'id_campione',
'DOCUMENTAZIONE': 'id_documentazione'
}
#creazione del cursore di lettura
if os.name == 'posix':
home = os.environ['HOME']
elif os.name == 'nt':
home = os.environ['HOMEPATH']
####RICAVA I DATI IN LETTURA PER LA CONNESSIONE DALLA GUI
conn_str_dict_read = {
"server": str(self.comboBox_server_rd.currentText()),
"user": str(self.lineEdit_username_rd.text()),
"password": str(self.lineEdit_pass_rd.text()),
"host": str(self.lineEdit_host_rd.text()),
"port": str(self.lineEdit_port_rd.text()),
"db_name": str(self.lineEdit_database_rd.text())
}
####CREA LA STRINGA DI CONNESSIONE IN LETTURA
if conn_str_dict_read["server"] == 'postgres':
try:
conn_str_read = "%s://%s:%s@%s:%s/%s%s?charset=utf8" % (
"postgresql", conn_str_dict_read["user"],
conn_str_dict_read["password"], conn_str_dict_read["host"],
conn_str_dict_read["port"], conn_str_dict_read["db_name"],
"?sslmode=allow")
except:
conn_str_read = "%s://%s:%s@%s:%d/%s" % (
"postgresql", conn_str_dict_read["user"],
conn_str_dict_read["password"], conn_str_dict_read["host"],
conn_str_dict_read["port"], conn_str_dict_read["db_name"])
elif conn_str_dict_read["server"] == 'sqlite':
sqlite_DB_path = ('%s%s%s') % (
home, os.sep, "pyarchinit_DB_folder"
) #"C:\\Users\\Windows\\Dropbox\\pyarchinit_san_marco\\" fare modifiche anche in pyarchinit_pyqgis
dbname_abs = sqlite_DB_path + os.sep + conn_str_dict_read["db_name"]
conn_str_read = "%s:///%s" % (conn_str_dict_read["server"],
dbname_abs)
QMessageBox.warning(self, "Alert",
str(conn_str_dict_read["db_name"]),
QMessageBox.Ok)
####SI CONNETTE AL DATABASE
self.DB_MANAGER_read = Pyarchinit_db_management(conn_str_read)
test = self.DB_MANAGER_read.connection()
test = str(test)
if test == "":
QMessageBox.warning(self, "Messaggio",
"Connessione avvenuta con successo",
QMessageBox.Ok)
elif test.find("create_engine") != -1:
QMessageBox.warning(
self, "Alert",
"Verifica i parametri di connessione. <br> Se sono corretti RIAVVIA QGIS",
QMessageBox.Ok)
else:
QMessageBox.warning(self, "Alert",
"Errore di connessione: <br>" + str(test),
QMessageBox.Ok)
####LEGGE I RECORD IN BASE AL PARAMETRO CAMPO=VALORE
search_dict = {
self.lineEdit_field_rd.text():
"'" + str(self.lineEdit_value_rd.text()) + "'"
}
mapper_class_read = str(self.comboBox_mapper_read.currentText())
res_read = self.DB_MANAGER_read.query_bool(search_dict,
mapper_class_read)
####INSERISCE I DATI DA UPLOADARE DENTRO ALLA LISTA DATA_LIST_TOIMP
data_list_toimp = []
for i in res_read:
data_list_toimp.append(i)
QMessageBox.warning(self, "Totale record da importare",
str(len(data_list_toimp)), QMessageBox.Ok)
#creazione del cursore di scrittura
####RICAVA I DATI IN LETTURA PER LA CONNESSIONE DALLA GUI
conn_str_dict_write = {
"server": str(self.comboBox_server_wt.currentText()),
"user": str(self.lineEdit_username_wt.text()),
"password": str(self.lineEdit_pass_wt.text()),
"host": str(self.lineEdit_host_wt.text()),
"port": str(self.lineEdit_port_wt.text()),
"db_name": str(self.lineEdit_database_wt.text())
}
####CREA LA STRINGA DI CONNESSIONE IN LETTURA
if conn_str_dict_write["server"] == 'postgres':
try:
conn_str_write = "%s://%s:%s@%s:%s/%s%s?charset=utf8" % (
"postgresql", conn_str_dict_writed["user"],
conn_str_dict_write["password"],
conn_str_dict_write["host"], conn_str_dict_write["port"],
conn_str_dict_write["db_name"], "?sslmode=allow")
except:
conn_str_write = "%s://%s:%s@%s:%d/%s" % (
"postgresql", conn_str_dict_write["user"],
conn_str_dict_write["password"],
conn_str_dict_write["host"],
int(conn_str_dict_write["port"]),
conn_str_dict_write["db_name"])
elif conn_str_dict_write["server"] == 'sqlite':
sqlite_DB_path = ('%s%s%s') % (
home, os.sep, "pyarchinit_DB_folder"
) #"C:\\Users\\Windows\\Dropbox\\pyarchinit_san_marco\\" fare modifiche anche in pyarchinit_pyqgis
dbname_abs = sqlite_DB_path + os.sep + conn_str_dict_write[
"db_name"]
conn_str_write = "%s:///%s" % (conn_str_dict_write["server"],
dbname_abs)
QMessageBox.warning(self, "Alert",
str(conn_str_dict_write["db_name"]),
QMessageBox.Ok)
####SI CONNETTE AL DATABASE IN SCRITTURA
self.DB_MANAGER_write = Pyarchinit_db_management(conn_str_write)
test = self.DB_MANAGER_write.connection()
test = str(test)
if test == "":
QMessageBox.warning(self, "Messaggio",
"Connessione avvenuta con successo",
QMessageBox.Ok)
elif test.find("create_engine") != -1:
QMessageBox.warning(
self, "Alert",
"Verifica i parametri di connessione. <br> Se sono corretti RIAVVIA QGIS",
QMessageBox.Ok)
else:
QMessageBox.warning(self, "Alert",
"Errore di connessione: <br>" + str(test),
QMessageBox.Ok)
mapper_class_write = str(self.comboBox_mapper_read.currentText())
####inserisce i dati dentro al database
#### US TABLE
if mapper_class_write == 'US':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_values(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1,
data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].area,
data_list_toimp[sing_rec].us,
data_list_toimp[sing_rec].d_stratigrafica,
data_list_toimp[sing_rec].d_interpretativa,
data_list_toimp[sing_rec].descrizione,
data_list_toimp[sing_rec].interpretazione,
data_list_toimp[sing_rec].periodo_iniziale,
data_list_toimp[sing_rec].fase_iniziale,
data_list_toimp[sing_rec].periodo_finale,
data_list_toimp[sing_rec].fase_finale,
data_list_toimp[sing_rec].scavato,
data_list_toimp[sing_rec].attivita,
data_list_toimp[sing_rec].anno_scavo,
data_list_toimp[sing_rec].metodo_di_scavo,
data_list_toimp[sing_rec].inclusi,
data_list_toimp[sing_rec].campioni,
data_list_toimp[sing_rec].rapporti,
data_list_toimp[sing_rec].data_schedatura,
data_list_toimp[sing_rec].schedatore,
data_list_toimp[sing_rec].formazione,
data_list_toimp[sing_rec].stato_di_conservazione,
data_list_toimp[sing_rec].colore,
data_list_toimp[sing_rec].consistenza,
data_list_toimp[sing_rec].struttura,
data_list_toimp[sing_rec].cont_per,
data_list_toimp[sing_rec].order_layer,
data_list_toimp[sing_rec].documentazione,
data_list_toimp[sing_rec].
unita_tipo, #campi aggiunti per USM
data_list_toimp[sing_rec].settore,
data_list_toimp[sing_rec].quad_par,
data_list_toimp[sing_rec].ambient,
data_list_toimp[sing_rec].saggio,
data_list_toimp[sing_rec].elem_datanti,
data_list_toimp[sing_rec].funz_statica,
data_list_toimp[sing_rec].lavorazione,
data_list_toimp[sing_rec].spess_giunti,
data_list_toimp[sing_rec].letti_posa,
data_list_toimp[sing_rec].alt_mod,
data_list_toimp[sing_rec].un_ed_riass,
data_list_toimp[sing_rec].reimp,
data_list_toimp[sing_rec].posa_opera,
data_list_toimp[sing_rec].quota_min_usm,
data_list_toimp[sing_rec].quota_max_usm,
data_list_toimp[sing_rec].cons_legante,
data_list_toimp[sing_rec].col_legante,
data_list_toimp[sing_rec].aggreg_legante,
data_list_toimp[sing_rec].con_text_mat,
data_list_toimp[sing_rec].col_materiale,
data_list_toimp[sing_rec].inclusi_materiali_usm)
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####SITE TABLE
if mapper_class_write == 'SITE':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_site_values(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].nazione,
data_list_toimp[sing_rec].regione,
data_list_toimp[sing_rec].comune,
data_list_toimp[sing_rec].descrizione,
data_list_toimp[sing_rec].provincia,
data_list_toimp[sing_rec].definizione_sito,
data_list_toimp[sing_rec].find_check)
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####PERIODIZZAZIONE TABLE
if mapper_class_write == 'PERIODIZZAZIONE':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_periodizzazione_values(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].periodo,
data_list_toimp[sing_rec].fase,
data_list_toimp[sing_rec].cron_iniziale,
data_list_toimp[sing_rec].cron_finale,
data_list_toimp[sing_rec].descrizione,
data_list_toimp[sing_rec].datazione_estesa,
data_list_toimp[sing_rec].cont_per)
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####INVENTARIO MATERIALI TABLE
if mapper_class_write == 'INVENTARIO_MATERIALI':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_values_reperti(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].numero_inventario,
data_list_toimp[sing_rec].tipo_reperto,
data_list_toimp[sing_rec].criterio_schedatura,
data_list_toimp[sing_rec].definizione,
data_list_toimp[sing_rec].descrizione,
data_list_toimp[sing_rec].area,
data_list_toimp[sing_rec].us,
data_list_toimp[sing_rec].lavato,
data_list_toimp[sing_rec].nr_cassa,
data_list_toimp[sing_rec].luogo_conservazione,
data_list_toimp[sing_rec].stato_conservazione,
data_list_toimp[sing_rec].datazione_reperto,
data_list_toimp[sing_rec].elementi_reperto,
data_list_toimp[sing_rec].misurazioni,
data_list_toimp[sing_rec].rif_biblio,
data_list_toimp[sing_rec].tecnologie,
data_list_toimp[sing_rec].forme_minime,
data_list_toimp[sing_rec].forme_massime,
data_list_toimp[sing_rec].totale_frammenti,
data_list_toimp[sing_rec].corpo_ceramico,
data_list_toimp[sing_rec].rivestimento,
data_list_toimp[sing_rec].diametro_orlo,
data_list_toimp[sing_rec].peso,
data_list_toimp[sing_rec].tipo,
data_list_toimp[sing_rec].eve_orlo,
data_list_toimp[sing_rec].repertato,
data_list_toimp[sing_rec].diagnostico)
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####STRUTTURA TABLE
if mapper_class_write == 'STRUTTURA':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_struttura_values(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].sigla_struttura,
data_list_toimp[sing_rec].numero_struttura,
data_list_toimp[sing_rec].categoria_struttura,
data_list_toimp[sing_rec].tipologia_struttura,
data_list_toimp[sing_rec].definizione_struttura,
data_list_toimp[sing_rec].descrizione,
data_list_toimp[sing_rec].interpretazione,
data_list_toimp[sing_rec].periodo_iniziale,
data_list_toimp[sing_rec].fase_iniziale,
data_list_toimp[sing_rec].periodo_finale,
data_list_toimp[sing_rec].fase_finale,
data_list_toimp[sing_rec].datazione_estesa,
data_list_toimp[sing_rec].materiali_impiegati,
data_list_toimp[sing_rec].elementi_strutturali,
data_list_toimp[sing_rec].rapporti_struttura,
data_list_toimp[sing_rec].misure_struttura)
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####TAFONOMIA TABLE
if mapper_class_write == 'TAFONOMIA':
for sing_rec in range(len(data_list_toimp)):
#blocco oritentamento_azimut
test_azimut = data_list_toimp[sing_rec].orientamento_azimut
if test_azimut == "" or test_azimut == None:
orientamento_azimut = None
else:
orientamento_azimut = float(
data_list_toimp[sing_rec].orientamento_azimut)
## if conn_str_dict_write['server'] == 'postgres':
## orientamento_azimut = float(orientamento_azimut)
##
#blocco oritentamento_azimut
test_lunghezza_scheletro = data_list_toimp[
sing_rec].lunghezza_scheletro
if test_lunghezza_scheletro == "" or test_lunghezza_scheletro == None:
lunghezza_scheletro = None
else:
lunghezza_scheletro = float(
data_list_toimp[sing_rec].lunghezza_scheletro)
#blocco periodo_iniziale
test_per_iniz = data_list_toimp[sing_rec].periodo_iniziale
if test_per_iniz == "" or test_per_iniz == None:
per_iniz = None
else:
per_iniz = int(data_list_toimp[sing_rec].periodo_iniziale)
#blocco fase_iniziale
test_fas_iniz = data_list_toimp[sing_rec].fase_iniziale
if test_fas_iniz == "" or test_fas_iniz == None:
fase_iniz = None
else:
fase_iniz = int(data_list_toimp[sing_rec].fase_iniziale)
#blocco periodo_finale
test_per_fin = data_list_toimp[sing_rec].periodo_finale
if test_per_fin == "" or test_per_fin == None:
per_fin = None
else:
per_fin = int(data_list_toimp[sing_rec].periodo_finale)
#blocco fase_finale
test_fas_fin = data_list_toimp[sing_rec].fase_finale
if test_fas_fin == "" or test_fas_fin == None:
fase_fin = None
else:
fase_fin = int(data_list_toimp[sing_rec].fase_finale)
data = self.DB_MANAGER_write.insert_values_tafonomia(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, str(data_list_toimp[sing_rec].sito),
int(data_list_toimp[sing_rec].nr_scheda_taf),
str(data_list_toimp[sing_rec].sigla_struttura),
int(data_list_toimp[sing_rec].nr_struttura),
int(data_list_toimp[sing_rec].nr_individuo),
str(data_list_toimp[sing_rec].rito),
str(data_list_toimp[sing_rec].descrizione_taf),
str(data_list_toimp[sing_rec].interpretazione_taf),
str(data_list_toimp[sing_rec].segnacoli),
str(data_list_toimp[sing_rec].canale_libatorio_si_no),
str(data_list_toimp[sing_rec].oggetti_rinvenuti_esterno),
str(data_list_toimp[sing_rec].stato_di_conservazione),
str(data_list_toimp[sing_rec].copertura_tipo),
str(data_list_toimp[sing_rec].tipo_contenitore_resti),
str(data_list_toimp[sing_rec].orientamento_asse),
orientamento_azimut,
str(data_list_toimp[sing_rec].corredo_presenza),
str(data_list_toimp[sing_rec].corredo_tipo),
str(data_list_toimp[sing_rec].corredo_descrizione),
lunghezza_scheletro,
str(data_list_toimp[sing_rec].posizione_scheletro),
str(data_list_toimp[sing_rec].posizione_cranio),
str(data_list_toimp[sing_rec].posizione_arti_superiori),
str(data_list_toimp[sing_rec].posizione_arti_inferiori),
str(data_list_toimp[sing_rec].completo_si_no),
str(data_list_toimp[sing_rec].disturbato_si_no),
str(data_list_toimp[sing_rec].in_connessione_si_no),
str(data_list_toimp[sing_rec].caratteristiche), per_iniz,
fase_iniz, per_fin, fase_fin,
str(data_list_toimp[sing_rec].datazione_estesa),
str(data_list_toimp[sing_rec].misure_tafonomia))
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####INDIVIDUI TABLE
if mapper_class_write == 'SCHEDAIND':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_values_ind(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].area,
data_list_toimp[sing_rec].us,
data_list_toimp[sing_rec].nr_individuo,
data_list_toimp[sing_rec].data_schedatura,
data_list_toimp[sing_rec].schedatore,
data_list_toimp[sing_rec].sesso,
data_list_toimp[sing_rec].eta_min,
data_list_toimp[sing_rec].eta_max,
data_list_toimp[sing_rec].classi_eta,
data_list_toimp[sing_rec].osservazioni)
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####CAMPIONE TABLE
if mapper_class_write == 'CAMPIONE':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_values_campioni(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].area,
data_list_toimp[sing_rec].nr_campione,
data_list_toimp[sing_rec].tipo_campione,
data_list_toimp[sing_rec].descrizione,
data_list_toimp[sing_rec].area,
data_list_toimp[sing_rec].us,
data_list_toimp[sing_rec].numero_inventario_materiale,
data_list_toimp[sing_rec].nr_cassa,
data_list_toimp[sing_rec].luogo_conservazione)
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####DOCUMENTAZIONE TABLE
if mapper_class_write == 'DOCUMENTAZIONE':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_values_documentazione(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].nome_doc,
data_list_toimp[sing_rec].data,
data_list_toimp[sing_rec].tipo_documentazione,
data_list_toimp[sing_rec].sorgente,
data_list_toimp[sing_rec].scala,
data_list_toimp[sing_rec].disegnatore,
data_list_toimp[sing_rec].note)
## try:
self.DB_MANAGER_write.insert_data_session(data)
## except Exception, e:
## e_str = str(e)
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(e_str), QMessageBox.Ok)
## if e_str.__contains__("Integrity"):
## msg = 'id_us' + " gia' presente nel database"
## else:
## msg = e
## QMessageBox.warning(self, "Errore", "Attenzione 1 ! \n"+ str(msg), QMessageBox.Ok)
## return 0
##
####UT TABLE
if mapper_class_write == 'UT':
for sing_rec in range(len(data_list_toimp)):
data = self.DB_MANAGER_write.insert_ut_values(
self.DB_MANAGER_write.max_num_id(
mapper_class_write,
id_table_class_mapper_conv_dict[mapper_class_write]) +
1, data_list_toimp[sing_rec].sito,
data_list_toimp[sing_rec].progetto,
data_list_toimp[sing_rec].nr_ut,
data_list_toimp[sing_rec].ut_letterale,
data_list_toimp[sing_rec].def_ut,
data_list_toimp[sing_rec].descrizione_ut,
data_list_toimp[sing_rec].interpretazione_ut,
data_list_toimp[sing_rec].nazione,
data_list_toimp[sing_rec].regione,
data_list_toimp[sing_rec].provincia,
data_list_toimp[sing_rec].comune,
data_list_toimp[sing_rec].frazione,
data_list_toimp[sing_rec].localita,
data_list_toimp[sing_rec].indirizzo,
data_list_toimp[sing_rec].nr_civico,
data_list_toimp[sing_rec].carta_topo_igm,
data_list_toimp[sing_rec].coord_geografiche,
data_list_toimp[sing_rec].coord_piane,
data_list_toimp[sing_rec].andamento_terreno_pendenza,
data_list_toimp[sing_rec].utilizzo_suolo_vegetazione,
data_list_toimp[sing_rec].descrizione_empirica_suolo,
data_list_toimp[sing_rec].descrizione_luogo,
data_list_toimp[sing_rec].metodo_rilievo_e_ricognizione,
data_list_toimp[sing_rec].geometria,
data_list_toimp[sing_rec].bibliografia,
data_list_toimp[sing_rec].data,
data_list_toimp[sing_rec].ora_meteo,
data_list_toimp[sing_rec].descrizione_luogo,
data_list_toimp[sing_rec].responsabile,
data_list_toimp[sing_rec].dimensioni_ut,
data_list_toimp[sing_rec].rep_per_mq,
data_list_toimp[sing_rec].rep_datanti,
data_list_toimp[sing_rec].periodo_I,
data_list_toimp[sing_rec].datazione_I,
data_list_toimp[sing_rec].responsabile,
data_list_toimp[sing_rec].interpretazione_I,
data_list_toimp[sing_rec].periodo_II,
data_list_toimp[sing_rec].datazione_II,
data_list_toimp[sing_rec].interpretazione_II,
data_list_toimp[sing_rec].documentazione,
data_list_toimp[sing_rec].enti_tutela_vincoli,
data_list_toimp[sing_rec].indagini_preliminari)
## try:
self.DB_MANAGER_write.insert_data_session(data)
class pyarchinit_Documentazione(QDialog, Ui_DialogDocumentazione_tipo_doc):
MSG_BOX_TITLE = "PyArchInit - pyarchinit_version 0.4 - Scheda Documentazione"
DATA_LIST = []
DATA_LIST_REC_CORR = []
DATA_LIST_REC_TEMP = []
REC_CORR = 0
REC_TOT = 0
STATUS_ITEMS = {"b": "Usa", "f": "Trova", "n": "Nuovo Record"}
BROWSE_STATUS = "b"
SORT_MODE = 'asc'
SORTED_ITEMS = {"n": "Non ordinati", "o": "Ordinati"}
SORT_STATUS = "n"
UTILITY = Utility()
DB_MANAGER = ""
TABLE_NAME = 'documentazione_table'
MAPPER_TABLE_CLASS = "DOCUMENTAZIONE"
NOME_SCHEDA = "Scheda Documentazione"
ID_TABLE = "id_documentazione"
CONVERSION_DICT = {
ID_TABLE: ID_TABLE,
"Sito": "sito",
"Nome documentazione": "nome_doc",
"Data": "data",
"Tipo documentazione": "tipo_documentazione",
"Sorgente": "sorgente",
"Scala": "scala",
"Disegnatore": "disegnatore",
"Note": "note",
}
SORT_ITEMS = [
ID_TABLE,
"Sito",
"Nome documentazione",
"Data",
"Tipo documentazione",
"Sorgente",
"Scala",
"Disegnatore",
"Note",
]
TABLE_FIELDS = [
"sito",
"nome_doc",
"data",
"tipo_documentazione",
"sorgente",
"scala",
"disegnatore",
"note",
]
DB_SERVER = "not defined" ####nuovo sistema sort
def __init__(self, iface):
self.iface = iface
self.pyQGIS = Pyarchinit_pyqgis(self.iface)
QDialog.__init__(self)
self.setupUi(self)
self.currentLayerId = None
try:
self.on_pushButton_connect_pressed()
except Exception as e:
QMessageBox.warning(self, "Sistema di connessione", str(e),
QMessageBox.Ok)
def enable_button(self, n):
self.pushButton_connect.setEnabled(n)
self.pushButton_new_rec.setEnabled(n)
self.pushButton_view_all.setEnabled(n)
self.pushButton_first_rec.setEnabled(n)
self.pushButton_last_rec.setEnabled(n)
self.pushButton_prev_rec.setEnabled(n)
self.pushButton_next_rec.setEnabled(n)
self.pushButton_delete.setEnabled(n)
self.pushButton_new_search.setEnabled(n)
self.pushButton_search_go.setEnabled(n)
self.pushButton_sort.setEnabled(n)
def enable_button_search(self, n):
self.pushButton_connect.setEnabled(n)
self.pushButton_new_rec.setEnabled(n)
self.pushButton_view_all.setEnabled(n)
self.pushButton_first_rec.setEnabled(n)
self.pushButton_last_rec.setEnabled(n)
self.pushButton_prev_rec.setEnabled(n)
self.pushButton_next_rec.setEnabled(n)
self.pushButton_delete.setEnabled(n)
self.pushButton_save.setEnabled(n)
self.pushButton_sort.setEnabled(n)
def on_pushButton_connect_pressed(self):
from pyarchinit_conn_strings import *
conn = Connection()
conn_str = conn.conn_str()
test_conn = conn_str.find('sqlite')
if test_conn == 0:
self.DB_SERVER = "sqlite"
try:
self.DB_MANAGER = Pyarchinit_db_management(conn_str)
self.DB_MANAGER.connection()
self.charge_records() #charge records from DB
#check if DB is empty
if bool(self.DATA_LIST) == True:
self.REC_TOT, self.REC_CORR = len(self.DATA_LIST), 0
self.DATA_LIST_REC_TEMP = self.DATA_LIST_REC_CORR = self.DATA_LIST[
0]
self.BROWSE_STATUS = 'b'
self.label_status.setText(
self.STATUS_ITEMS[self.BROWSE_STATUS])
self.label_sort.setText(self.SORTED_ITEMS["n"])
self.set_rec_counter(len(self.DATA_LIST), self.REC_CORR + 1)
self.charge_list()
self.fill_fields()
else:
QMessageBox.warning(
self, "BENVENUTO",
"Benvenuto in pyArchInit" + self.NOME_SCHEDA +
". Il database e' vuoto. Premi 'Ok' e buon lavoro!",
QMessageBox.Ok)
self.charge_list()
self.BROWSE_STATUS = 'x'
self.on_pushButton_new_rec_pressed()
except Exception as e:
e = str(e)
if e.find("no such table"):
QMessageBox.warning(
self, "Alert",
"La connessione e' fallita <br><br> Tabella non presente. E' NECESSARIO RIAVVIARE QGIS"
+ str(e), QMessageBox.Ok)
else:
QMessageBox.warning(
self, "Alert",
"Attenzione rilevato bug! Segnalarlo allo sviluppatore<br> Errore: <br>"
+ str(e), QMessageBox.Ok)
####################################
def charge_list(self):
sito_vl = self.UTILITY.tup_2_list_III(
self.DB_MANAGER.group_by('site_table', 'sito', 'SITE'))
try:
sito_vl.remove('')
except:
pass
self.comboBox_sito_doc.clear()
sito_vl.sort()
self.comboBox_sito_doc.addItems(sito_vl)
###################################
#buttons functions
def generate_list_pdf(self):
data_list = []
for i in range(len(self.DATA_LIST)):
sito = str(self.DATA_LIST[i].sito)
tipo_doc = str(self.DATA_LIST[i].tipo_documentazione)
nome_doc = str(self.DATA_LIST[i].nome_doc)
note = str(self.DATA_LIST[i].note)
res_us_doc = self.DB_MANAGER.select_us_doc_from_db_sql(
sito, tipo_doc, nome_doc)
res_usneg_doc = self.DB_MANAGER.select_usneg_doc_from_db_sql(
sito, tipo_doc, nome_doc)
elenco_us_doc = []
elenco_usneg_doc = []
if bool(res_us_doc) == True:
for sing_rec in res_us_doc:
tup_area_us = (int(sing_rec[1]), int(sing_rec[3]))
elenco_us_doc.append(tup_area_us)
if bool(res_usneg_doc) == True:
for sing_rec in res_usneg_doc:
tup_area_usneg = (int(sing_rec[2]), int(sing_rec[3]))
elenco_usneg_doc.append(tup_area_usneg)
elenco_us_pdf = elenco_us_doc + elenco_usneg_doc
string_to_pdf = ""
if bool(elenco_us_pdf) == True:
elenco_us_pdf.sort()
area_corr = str(elenco_us_pdf[0][0])
us_elenco = ""
string_to_pdf = ""
for rec_us in range(len(elenco_us_pdf)):
if area_corr == str(elenco_us_pdf[rec_us][0]):
us_elenco += str(elenco_us_pdf[rec_us][1]) + ", "
else:
if string_to_pdf == "":
string_to_pdf = "Area " + area_corr + ": " + us_elenco[:
-2]
area_corr = str(elenco_us_pdf[rec_us][0])
us_elenco = str(elenco_us_pdf[rec_us][1]) + ", "
else:
string_to_pdf += "<br/>Area " + area_corr + ": " + us_elenco[:
-2]
area_corr = str(elenco_us_pdf[rec_us][0])
us_elenco = str(elenco_us_pdf[rec_us][1]) + ", "
string_to_pdf += "<br/>Area " + area_corr + ": " + us_elenco[:
-2]
else:
pass
data_list.append([
str(self.DATA_LIST[i].sito), #1 - Sito
str(self.DATA_LIST[i].nome_doc), #2 - Area
str(self.DATA_LIST[i].data), #4 - definizione stratigrafica
str(self.DATA_LIST[i].tipo_documentazione
), #5 - definizione intepretata
str(self.DATA_LIST[i].sorgente), #6 - descrizione
str(self.DATA_LIST[i].scala), #7 - interpretazione
str(self.DATA_LIST[i].disegnatore), #8 - periodo iniziale
str(self.DATA_LIST[i].note), #9 - fase iniziale
note
])
return data_list
def on_pushButton_disegno_doc_pressed(self):
sing_layer = [self.DATA_LIST[self.REC_CORR]]
self.pyQGIS.charge_vector_layers_doc(sing_layer)
def on_pushButton_exp_scheda_doc_pressed(self):
single_Documentazione_pdf_sheet = generate_documentazione_pdf()
data_list = self.generate_list_pdf()
single_Documentazione_pdf_sheet.build_Documentazione_sheets(data_list)
def on_pushButton_exp_elenco_doc_pressed(self):
Documentazione_index_pdf = generate_documentazione_pdf()
data_list = self.generate_list_pdf()
Documentazione_index_pdf.build_index_Documentazione(
data_list, data_list[0][0])
def on_pushButtonPreview_pressed(self):
docstr = (' \"%s\"=\'%s\' AND \"%s\"=\'%s\' AND \"%s\"=\'%s\' ') % (
'sito', str(self.DATA_LIST[self.REC_CORR].sito), 'nome_doc',
str(self.DATA_LIST[self.REC_CORR].nome_doc), 'tipo_doc',
str(self.DATA_LIST[self.REC_CORR].tipo_documentazione))
QMessageBox.warning(self, "query", str(docstr), QMessageBox.Ok)
dlg = pyarchinit_doc_preview(self, docstr)
dlg.exec_()
def on_pushButton_sort_pressed(self):
if self.check_record_state() == 1:
pass
else:
dlg = SortPanelMain(self)
dlg.insertItems(self.SORT_ITEMS)
dlg.exec_()
items, order_type = dlg.ITEMS, dlg.TYPE_ORDER
self.SORT_ITEMS_CONVERTED = []
for i in items:
self.SORT_ITEMS_CONVERTED.append(self.CONVERSION_DICT[str(i)])
self.SORT_MODE = order_type
self.empty_fields()
id_list = []
for i in self.DATA_LIST:
id_list.append(ast.literal_eval("i." + self.ID_TABLE))
self.DATA_LIST = []
temp_data_list = self.DB_MANAGER.query_sort(
id_list, self.SORT_ITEMS_CONVERTED, self.SORT_MODE,
self.MAPPER_TABLE_CLASS, self.ID_TABLE)
for i in temp_data_list:
self.DATA_LIST.append(i)
self.BROWSE_STATUS = "b"
self.label_status.setText(self.STATUS_ITEMS[self.BROWSE_STATUS])
if type(self.REC_CORR) == "<type 'str'>":
corr = 0
else:
corr = self.REC_CORR
self.REC_TOT, self.REC_CORR = len(self.DATA_LIST), 0
self.DATA_LIST_REC_TEMP = self.DATA_LIST_REC_CORR = self.DATA_LIST[
0]
self.SORT_STATUS = "o"
self.label_sort.setText(self.SORTED_ITEMS[self.SORT_STATUS])
self.set_rec_counter(len(self.DATA_LIST), self.REC_CORR + 1)
self.fill_fields()
def on_pushButton_new_rec_pressed(self):
if bool(self.DATA_LIST) == True:
if self.data_error_check() == 1:
pass
else:
if self.BROWSE_STATUS == "b":
if bool(self.DATA_LIST) == True:
if self.records_equal_check() == 1:
msg = self.update_if(
QMessageBox.warning(
self, 'Errore',
"Il record e' stato modificato. Vuoi salvare le modifiche?",
QMessageBox.Cancel, 1))
##########################################
#set the GUI for a new record
if self.BROWSE_STATUS != "n":
self.BROWSE_STATUS = "n"
self.label_status.setText(self.STATUS_ITEMS[self.BROWSE_STATUS])
self.empty_fields()
self.label_sort.setText(self.SORTED_ITEMS["n"])
self.setComboBoxEditable(["self.comboBox_sito_doc"], 1)
self.setComboBoxEnable(["self.comboBox_sito_doc"], "True")
self.setComboBoxEnable(["self.comboBox_tipo_doc"], "True")
self.setComboBoxEnable(["self.lineEdit_nome_doc"], "True")
self.set_rec_counter('', '')
self.enable_button(0)
###########################################
def on_pushButton_save_pressed(self):
#save record
if self.BROWSE_STATUS == "b":
if self.data_error_check() == 0:
if self.records_equal_check() == 1:
self.update_if(
QMessageBox.warning(
self, 'ATTENZIONE',
"Il record e' stato modificato. Vuoi salvare le modifiche?",
QMessageBox.Cancel, 1))
self.label_sort.setText(self.SORTED_ITEMS["n"])
self.enable_button(1)
self.fill_fields(self.REC_CORR)
else:
QMessageBox.warning(
self, "ATTENZIONE",
"Non è stata realizzata alcuna modifica.",
QMessageBox.Ok)
else:
if self.data_error_check() == 0:
test_insert = self.insert_new_rec()
if test_insert == 1:
self.empty_fields()
self.label_sort.setText(self.SORTED_ITEMS["n"])
self.charge_list()
self.charge_records()
self.BROWSE_STATUS = "b"
self.label_status.setText(
self.STATUS_ITEMS[self.BROWSE_STATUS])
self.REC_TOT, self.REC_CORR = len(
self.DATA_LIST), len(self.DATA_LIST) - 1
self.set_rec_counter(self.REC_TOT, self.REC_CORR + 1)
##################################################
self.setComboBoxEditable(["self.comboBox_sito_doc"], 1)
self.setComboBoxEnable(["self.comboBox_sito_doc"], "False")
self.setComboBoxEnable(["self.comboBox_tipo_doc"], "False")
self.setComboBoxEnable(["self.lineEdit_nome_doc"], "False")
self.fill_fields(self.REC_CORR)
self.enable_button(1)
else:
pass
##################################################
def data_error_check(self):
test = 0
EC = Error_check()
if EC.data_is_empty(str(self.comboBox_sito_doc.currentText())) == 0:
QMessageBox.warning(
self, "ATTENZIONE",
"Campo Sito. \n Il campo non deve essere vuoto",
QMessageBox.Ok)
test = 1
if EC.data_is_empty(str(self.comboBox_tipo_doc.currentText())) == 0:
QMessageBox.warning(
self, "ATTENZIONE",
"Campo Tipo documentazione \n Il campo non deve essere vuoto",
QMessageBox.Ok)
test = 1
if EC.data_is_empty(str(self.lineEdit_nome_doc.text())) == 0:
QMessageBox.warning(
self, "ATTENZIONE",
"Campo Nome documentazione \n Il campo non deve essere vuoto",
QMessageBox.Ok)
test = 1
return test
def insert_new_rec(self):
try:
data = self.DB_MANAGER.insert_values_documentazione(
self.DB_MANAGER.max_num_id(self.MAPPER_TABLE_CLASS,
self.ID_TABLE) + 1,
str(self.comboBox_sito_doc.currentText()), #1 - Sito
str(self.lineEdit_nome_doc.text()), #2 - Nome Documentazione
str(self.lineEdit_data_doc.text()), #3 - Data
str(self.comboBox_tipo_doc.currentText()
), #4 - Tipo Documentazione
str(self.comboBox_sorgente_doc.currentText()), #5 - Sorgente
str(self.comboBox_scala_doc.currentText()), #6 - Scala
str(self.lineEdit_disegnatore_doc.text()), #7 - Disegnatore
str(self.textEdit_note_doc.toPlainText())) #8 - Note
try:
self.DB_MANAGER.insert_data_session(data)
return 1
except Exception as e:
e_str = str(e)
if e_str.__contains__("Integrity"):
msg = self.ID_TABLE + " gia' presente nel database"
else:
msg = e
QMessageBox.warning(self, "Errore",
"Attenzione 1 ! \n" + str(msg),
QMessageBox.Ok)
return 0
except Exception as e:
QMessageBox.warning(self, "Errore", "Attenzione 2 ! \n" + str(e),
QMessageBox.Ok)
return 0
def check_record_state(self):
ec = self.data_error_check()
if ec == 1:
return 1 #ci sono errori di immissione
elif self.records_equal_check() == 1 and ec == 0:
self.update_if(
QMessageBox.warning(
self, 'Errore',
"Il record e' stato modificato. Vuoi salvare le modifiche?",
QMessageBox.Cancel, 1))
#self.charge_records() incasina lo stato trova
return 0 #non ci sono errori di immissione
def on_pushButton_view_all_pressed(self):
if self.check_record_state() == 1:
pass
else:
self.empty_fields()
self.charge_records()
self.fill_fields()
self.BROWSE_STATUS = "b"
self.label_status.setText(self.STATUS_ITEMS[self.BROWSE_STATUS])
if type(self.REC_CORR) == "<type 'str'>":
corr = 0
else:
corr = self.REC_CORR
self.set_rec_counter(len(self.DATA_LIST), self.REC_CORR + 1)
self.REC_TOT, self.REC_CORR = len(self.DATA_LIST), 0
self.DATA_LIST_REC_TEMP = self.DATA_LIST_REC_CORR = self.DATA_LIST[
0]
self.label_sort.setText(self.SORTED_ITEMS["n"])
#records surf functions
def on_pushButton_first_rec_pressed(self):
if self.check_record_state() == 1:
pass
else:
try:
self.empty_fields()
self.REC_TOT, self.REC_CORR = len(self.DATA_LIST), 0
self.fill_fields(0)
self.set_rec_counter(self.REC_TOT, self.REC_CORR + 1)
except Exception as e:
QMessageBox.warning(self, "Errore", str(e), QMessageBox.Ok)
def on_pushButton_last_rec_pressed(self):
if self.check_record_state() == 1:
pass
else:
try:
self.empty_fields()
self.REC_TOT, self.REC_CORR = len(
self.DATA_LIST), len(self.DATA_LIST) - 1
self.fill_fields(self.REC_CORR)
self.set_rec_counter(self.REC_TOT, self.REC_CORR + 1)
except Exception as e:
QMessageBox.warning(self, "Errore", str(e), QMessageBox.Ok)
def on_pushButton_prev_rec_pressed(self):
if self.check_record_state() == 1:
pass
else:
self.REC_CORR = self.REC_CORR - 1
if self.REC_CORR == -1:
self.REC_CORR = 0
QMessageBox.warning(self, "Errore", "Sei al primo record!",
QMessageBox.Ok)
else:
try:
self.empty_fields()
self.fill_fields(self.REC_CORR)
self.set_rec_counter(self.REC_TOT, self.REC_CORR + 1)
except Exception as e:
QMessageBox.warning(self, "Errore", str(e), QMessageBox.Ok)
def on_pushButton_next_rec_pressed(self):
if self.check_record_state() == 1:
pass
else:
self.REC_CORR = self.REC_CORR + 1
if self.REC_CORR >= self.REC_TOT:
self.REC_CORR = self.REC_CORR - 1
QMessageBox.warning(self, "Errore", "Sei all'ultimo record!",
QMessageBox.Ok)
else:
try:
self.empty_fields()
self.fill_fields(self.REC_CORR)
self.set_rec_counter(self.REC_TOT, self.REC_CORR + 1)
except Exception as e:
QMessageBox.warning(self, "Errore", str(e), QMessageBox.Ok)
def on_pushButton_delete_pressed(self):
msg = QMessageBox.warning(
self, "Attenzione!!!",
"Vuoi veramente eliminare il record? \n L'azione è irreversibile",
QMessageBox.Cancel, 1)
if msg != 1:
QMessageBox.warning(self, "Messaggio!!!", "Azione Annullata!")
else:
try:
id_to_delete = ast.literal_eval(
"self.DATA_LIST[self.REC_CORR]." + self.ID_TABLE)
self.DB_MANAGER.delete_one_record(self.TABLE_NAME,
self.ID_TABLE, id_to_delete)
self.charge_records() #charge records from DB
QMessageBox.warning(self, "Messaggio!!!", "Record eliminato!")
except Exception as e:
QMessageBox.warning(self, "Messaggio!!!",
"Tipo di errore: " + str(e))
if bool(self.DATA_LIST) == False:
QMessageBox.warning(self, "Attenzione", "Il database è vuoto!",
QMessageBox.Ok)
self.DATA_LIST = []
self.DATA_LIST_REC_CORR = []
self.DATA_LIST_REC_TEMP = []
self.REC_CORR = 0
self.REC_TOT = 0
self.empty_fields()
self.set_rec_counter(0, 0)
#check if DB is empty
if bool(self.DATA_LIST) == True:
self.REC_TOT, self.REC_CORR = len(self.DATA_LIST), 0
self.DATA_LIST_REC_TEMP = self.DATA_LIST_REC_CORR = self.DATA_LIST[
0]
self.BROWSE_STATUS = "b"
self.label_status.setText(
self.STATUS_ITEMS[self.BROWSE_STATUS])
self.set_rec_counter(len(self.DATA_LIST), self.REC_CORR + 1)
self.charge_list()
self.fill_fields()
self.SORT_STATUS = "n"
self.label_sort.setText(self.SORTED_ITEMS[self.SORT_STATUS])
def on_pushButton_new_search_pressed(self):
if self.check_record_state() == 1:
pass
else:
self.enable_button_search(0)
################################################
#set the GUI for a new search
if self.BROWSE_STATUS != "f":
self.BROWSE_STATUS = "f"
self.label_status.setText(
self.STATUS_ITEMS[self.BROWSE_STATUS])
self.setComboBoxEnable(["self.comboBox_sito_doc"], "True")
self.setComboBoxEnable(["self.lineEdit_nome_doc"], "True")
self.setComboBoxEnable(["self.comboBox_tipo_doc"], "True")
self.setComboBoxEnable(["self.textEdit_note_doc"], "False")
self.setComboBoxEditable(["self.comboBox_sito_doc"], 1)
self.label_status.setText(
self.STATUS_ITEMS[self.BROWSE_STATUS])
self.set_rec_counter('', '')
self.label_sort.setText(self.SORTED_ITEMS["n"])
self.charge_list()
self.empty_fields()
################################################
def on_pushButton_search_go_pressed(self):
if self.BROWSE_STATUS != "f":
QMessageBox.warning(
self, "ATTENZIONE",
"Per eseguire una nuova ricerca clicca sul pulsante 'new search' ",
QMessageBox.Ok)
else:
search_dict = {
self.TABLE_FIELDS[0]:
"'" + str(self.comboBox_sito_doc.currentText()) +
"'", #1 - Sito
self.TABLE_FIELDS[1]:
"'" + str(self.lineEdit_nome_doc.text()) +
"'", #2 - Nome Documentazione
self.TABLE_FIELDS[2]:
"'" + str(self.lineEdit_data_doc.text()) + "'", #3 - Data
self.TABLE_FIELDS[3]:
"'" + str(self.comboBox_tipo_doc.currentText()) +
"'", #4 - Tipo Documentazione
self.TABLE_FIELDS[4]:
"'" + str(self.comboBox_sorgente_doc.currentText()) +
"'", #5 - Sorgente
self.TABLE_FIELDS[5]:
"'" + str(self.comboBox_scala_doc.currentText()) +
"'", #6 - Scala
self.TABLE_FIELDS[6]:
"'" + str(self.lineEdit_disegnatore_doc.text()) +
"'" #7 - Disegnatore
}
u = Utility()
search_dict = u.remove_empty_items_fr_dict(search_dict)
if bool(search_dict) == False:
QMessageBox.warning(
self, "ATTENZIONE",
"Non e' stata impostata alcuna ricerca!!!", QMessageBox.Ok)
else:
res = self.DB_MANAGER.query_bool(search_dict,
self.MAPPER_TABLE_CLASS)
if bool(res) == False:
QMessageBox.warning(self, "ATTENZIONE",
"Non e' stato trovato alcun record!",
QMessageBox.Ok)
self.set_rec_counter(len(self.DATA_LIST),
self.REC_CORR + 1)
self.DATA_LIST_REC_TEMP = self.DATA_LIST_REC_CORR = self.DATA_LIST[
0]
self.fill_fields(self.REC_CORR)
self.BROWSE_STATUS = "b"
self.label_status.setText(
self.STATUS_ITEMS[self.BROWSE_STATUS])
self.setComboBoxEnable(["self.comboBox_sito_doc"], "False")
self.setComboBoxEnable(["self.lineEdit_nome_doc"], "False")
self.setComboBoxEnable(["self.comboBox_tipo_doc"], "False")
self.setComboBoxEnable(["self.textEdit_note_doc"], "True")
self.setComboBoxEditable(["self.comboBox_sito_doc"], 1)
else:
self.DATA_LIST = []
for i in res:
self.DATA_LIST.append(i)
self.REC_TOT, self.REC_CORR = len(self.DATA_LIST), 0
self.DATA_LIST_REC_TEMP = self.DATA_LIST_REC_CORR = self.DATA_LIST[
0]
self.fill_fields()
self.BROWSE_STATUS = "b"
self.label_status.setText(
self.STATUS_ITEMS[self.BROWSE_STATUS])
self.set_rec_counter(len(self.DATA_LIST),
self.REC_CORR + 1)
if self.REC_TOT == 1:
strings = ("E' stato trovato", self.REC_TOT, "record")
else:
strings = ("Sono stati trovati", self.REC_TOT,
"records")
self.setComboBoxEnable(["self.comboBox_sito_doc"], "False")
self.setComboBoxEnable(["self.lineEdit_nome_doc"], "False")
self.setComboBoxEnable(["self.comboBox_tipo_doc"], "False")
self.setComboBoxEnable(["self.textEdit_note_doc"], "True")
self.setComboBoxEditable(["self.comboBox_sito_doc"], 1)
QMessageBox.warning(self, "Messaggio",
"%s %d %s" % strings, QMessageBox.Ok)
self.enable_button_search(1)
def on_pushButton_test_pressed(self):
pass
def update_if(self, msg):
rec_corr = self.REC_CORR
self.msg = msg
if self.msg == 1:
test = self.update_record()
if test == 1:
id_list = []
for i in self.DATA_LIST:
id_list.append(ast.literal_eval("i." + self.ID_TABLE))
self.DATA_LIST = []
if self.SORT_STATUS == "n":
temp_data_list = self.DB_MANAGER.query_sort(
id_list, [self.ID_TABLE], 'asc',
self.MAPPER_TABLE_CLASS, self.ID_TABLE
) #self.DB_MANAGER.query_bool(self.SEARCH_DICT_TEMP, self.MAPPER_TABLE_CLASS) #
else:
temp_data_list = self.DB_MANAGER.query_sort(
id_list, self.SORT_ITEMS_CONVERTED, self.SORT_MODE,
self.MAPPER_TABLE_CLASS, self.ID_TABLE)
for i in temp_data_list:
self.DATA_LIST.append(i)
self.BROWSE_STATUS = "b"
self.label_status.setText(
self.STATUS_ITEMS[self.BROWSE_STATUS])
if type(self.REC_CORR) == "<type 'str'>":
corr = 0
else:
corr = self.REC_CORR
return 1
elif test == 0:
return 0
#custom functions
def charge_records(self):
self.DATA_LIST = []
if self.DB_SERVER == 'sqlite':
for i in self.DB_MANAGER.query(
ast.literal_eval(self.MAPPER_TABLE_CLASS)):
self.DATA_LIST.append(i)
else:
id_list = []
for i in self.DB_MANAGER.query(
ast.literal_eval(self.MAPPER_TABLE_CLASS)):
id_list.append(ast.literal_eval("i." + self.ID_TABLE))
temp_data_list = self.DB_MANAGER.query_sort(
id_list, [self.ID_TABLE], 'asc', self.MAPPER_TABLE_CLASS,
self.ID_TABLE)
for i in temp_data_list:
self.DATA_LIST.append(i)
def datestrfdate(self):
now = date.today()
today = now.strftime("%d-%m-%Y")
return today
def table2dict(self, n):
self.tablename = n
row = ast.literal_eval(self.tablename + ".rowCount()")
col = ast.literal_eval(self.tablename + ".columnCount()")
lista = []
for r in range(row):
sub_list = []
for c in range(col):
value = ast.literal_eval(self.tablename + ".item(r,c)")
if bool(value) == True:
sub_list.append(str(value.text()))
lista.append(sub_list)
return lista
def empty_fields(self):
self.comboBox_sito_doc.setEditText("") #1 - Sito
self.lineEdit_nome_doc.clear() #2 - Nome Dcumentazione
self.lineEdit_data_doc.clear() #3 - Data
self.comboBox_tipo_doc.setEditText("") #4 - Tipo Documentazione
self.comboBox_sorgente_doc.setEditText("") #5 - Sorgente
self.comboBox_scala_doc.setEditText("") #6 - Scala
self.lineEdit_disegnatore_doc.clear() #7 - Dsegnatore
self.textEdit_note_doc.clear() #8 - Note
def fill_fields(self, n=0):
self.rec_num = n
str(
self.comboBox_sito_doc.setEditText(
self.DATA_LIST[self.rec_num].sito)) #1 - Sito
str(
self.lineEdit_nome_doc.setText(self.DATA_LIST[
self.rec_num].nome_doc)) #2 - Nome Dcumentazione
str(self.lineEdit_data_doc.setText(
self.DATA_LIST[self.rec_num].data)) #3 - Data
str(
self.comboBox_tipo_doc.setEditText(self.DATA_LIST[
self.rec_num].tipo_documentazione)) #4 - Tipo Documentazione
str(
self.comboBox_sorgente_doc.setEditText(
self.DATA_LIST[self.rec_num].sorgente)) #5 - Sorgente
str(
self.comboBox_scala_doc.setEditText(
self.DATA_LIST[self.rec_num].scala)) #6 - Scala
str(
self.lineEdit_disegnatore_doc.setText(
self.DATA_LIST[self.rec_num].disegnatore)) #7 - Dsegnatore
str(self.textEdit_note_doc.setText(
self.DATA_LIST[self.rec_num].note)) #8 - Note
def set_rec_counter(self, t, c):
self.rec_tot = t
self.rec_corr = c
self.label_rec_tot.setText(str(self.rec_tot))
self.label_rec_corrente.setText(str(self.rec_corr))
def set_LIST_REC_TEMP(self):
#data
self.DATA_LIST_REC_TEMP = [
str(self.comboBox_sito_doc.currentText()), #1 - Sito
str(self.lineEdit_nome_doc.text()), #2 - Nome Documentazione
str(self.lineEdit_data_doc.text()), #3 - Data
str(self.comboBox_tipo_doc.currentText()
), #4 - Tipo Documentazione
str(self.comboBox_sorgente_doc.currentText()), #5 - Sorgente
str(self.comboBox_scala_doc.currentText()), #6 - Scala
str(self.lineEdit_disegnatore_doc.text()), #7 - Disegnatore
str(self.textEdit_note_doc.toPlainText()) #8 - Note
]
def set_LIST_REC_CORR(self):
self.DATA_LIST_REC_CORR = []
for i in self.TABLE_FIELDS:
self.DATA_LIST_REC_CORR.append(
ast.literal_eval("unicode(self.DATA_LIST[self.REC_CORR]." + i +
")"))
def setComboBoxEnable(self, f, v):
field_names = f
value = v
for fn in field_names:
cmd = ('%s%s%s%s') % (fn, '.setEnabled(', v, ')')
ast.literal_eval(cmd)
def setComboBoxEditable(self, f, n):
field_names = f
value = n
for fn in field_names:
cmd = ('%s%s%d%s') % (fn, '.setEditable(', n, ')')
ast.literal_eval(cmd)
def rec_toupdate(self):
rec_to_update = self.UTILITY.pos_none_in_list(self.DATA_LIST_REC_TEMP)
return rec_to_update
def records_equal_check(self):
self.set_LIST_REC_TEMP()
self.set_LIST_REC_CORR()
if self.DATA_LIST_REC_CORR == self.DATA_LIST_REC_TEMP:
return 0
else:
return 1
def update_record(self):
try:
self.DB_MANAGER.update(self.MAPPER_TABLE_CLASS, self.ID_TABLE, [
ast.literal_eval("int(self.DATA_LIST[self.REC_CORR]." +
self.ID_TABLE + ")")
], self.TABLE_FIELDS, self.rec_toupdate())
return 1
except Exception as e:
QMessageBox.warning(
self, "Messaggio",
"Problema di encoding: sono stati inseriti accenti o caratteri non accettati dal database. Se chiudete ora la scheda senza correggere gli errori perderete i dati. Fare una copia di tutto su un foglio word a parte. Errore :"
+ str(e), QMessageBox.Ok)
return 0
def testing(self, name_file, message):
f = open(str(name_file), 'w')
f.write(str(message))
f.close()