コード例 #1
0
    def __init__(self, iface):
        self.iface = iface
        self.pyQGIS = Pyarchinit_pyqgis(self.iface)

        QDialog.__init__(self)
        self.setupUi(self)
        self.currentLayerId = None
        self.load_connection()
コード例 #2
0
 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)
コード例 #3
0
    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:
            pass
コード例 #4
0
    def __init__(self, iface, data_list, id_us_dict):
        self.iface = iface
        self.pyQGIS = Pyarchinit_pyqgis(self.iface)
        self.DATA_LIST = data_list
        self.ID_US_DICT = id_us_dict
        QDialog.__init__(self)
        self.setupUi(self)

        ##		self.textbox.setText('1 2 3 4')
        #self.on_draw()
        try:
            self.DB_connect()
        except:
            pass
    def __init__(self, iface):
        self.iface = iface
        self.pyQGIS = Pyarchinit_pyqgis(self.iface)
        QDialog.__init__(self)
        self.setupUi(self)

        self.currentLayerId = None
        try:
            self.connect()
        except:
            pass

        QObject.connect(self.dial_relative_cronology,
                        SIGNAL("valueChanged(int)"), self.set_max_num)
        QObject.connect(self.spinBox_relative_cronology,
                        SIGNAL("valueChanged(int)"), self.set_max_num)

        QObject.connect(self.dial_relative_cronology,
                        SIGNAL("valueChanged(int)"),
                        self.define_order_layer_value)
        QObject.connect(self.dial_relative_cronology,
                        SIGNAL("valueChanged(int)"),
                        self.spinBox_relative_cronology.setValue)

        QObject.connect(self.spinBox_relative_cronology,
                        SIGNAL("valueChanged(int)"),
                        self.define_order_layer_value)
        QObject.connect(self.spinBox_relative_cronology,
                        SIGNAL("valueChanged(int)"),
                        self.dial_relative_cronology.setValue)
コード例 #6
0
	def __init__(self, iface):
		self.iface = iface
		self.pyQGIS = Pyarchinit_pyqgis(self.iface)

		QDialog.__init__(self)
		self.setupUi(self)
		self.currentLayerId = None
		self.load_connection()
コード例 #7
0
	def __init__(self, iface):
		self.iface = iface
		self.pyQGIS = Pyarchinit_pyqgis(self.iface)
		QDialog.__init__(self)
		self.setupUi(self)
		QMessageBox.warning(self, "Alert", "Sistema sperimentale solo per lo sviluppo" ,  QMessageBox.Ok)
		#self.customize_GUI() #call for GUI customizations

		self.currentLayerId = None
コード例 #8
0
class pyarchinit_Schedaind(QDialog, Ui_DialogInd):
    MSG_BOX_TITLE = "PyArchInit - pyarchinit_US_version 0.4 - Scheda Individuo"
    DATA_LIST = []
    DATA_LIST_REC_CORR = []
    DATA_LIST_REC_TEMP = []
    REC_CORR = 0
    REC_TOT = 0
    BROWSE_STATUS = "b"
    STATUS_ITEMS = {"b": "Usa", "f": "Trova", "n": "Nuovo Record"}
    SORT_MODE = 'asc'
    SORTED_ITEMS = {"n": "Non ordinati", "o": "Ordinati"}
    SORT_STATUS = "n"
    UTILITY = Utility()
    DB_MANAGER = ""
    TABLE_NAME = 'individui_table'
    MAPPER_TABLE_CLASS = "SCHEDAIND"
    NOME_SCHEDA = "Scheda Individuo"
    ID_TABLE = "id_scheda_ind"
    CONVERSION_DICT = {
        ID_TABLE: ID_TABLE,
        "Sito": "sito",
        "US": "us",
        "Area": "area",
        "Nr. Individuo": "nr_individuo",
        "Data Schedatura": "data_schedatura",
        "Schedatore": "schedatore",
        "Stima del sesso": "sesso",
        "Stima dell'eta' di morte min": "eta_min",
        "Stima dell'eta' di morte max": "eta_max",
        "Classi di eta'": "classi_eta",
        "Osservazioni": "osservazioni"
    }
    SORT_ITEMS = [
        ID_TABLE, "Sito", "Area", "US", "Nr. Individuo", "Data schedatura",
        "Schedatore", "Stima del sesso", "Stima dell'eta' di morte min",
        "Stima dell'eta' di morte max", "Classi di eta'", "Osservazioni"
    ]

    TABLE_FIELDS = [
        'sito', 'area', 'us', 'nr_individuo', 'data_schedatura', 'schedatore',
        'sesso', 'eta_min', 'eta_max', 'classi_eta', 'osservazioni'
    ]

    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()
        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",
                    QMessageBox.Ok)
            else:
                QMessageBox.warning(
                    self, "Alert",
                    "Attenzione rilevato bug! Segnalarlo allo sviluppatore<br> Errore: <br>"
                    + str(e), QMessageBox.Ok)

    def customize_GUI(self):
        pass

    def loadMapPreview(self, mode=0):
        pass

    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.clear()

        sito_vl.sort()
        self.comboBox_sito.addItems(sito_vl)

    def charge_periodo_list(self):
        pass

    def charge_fase_iniz_list(self):
        pass

    def charge_fase_fin_list(self):
        pass

    #buttons functions

    def generate_list_pdf(self):
        data_list = []
        for i in range(len(self.DATA_LIST)):
            data_list.append([
                str(self.DATA_LIST[i].sito),  #1 - Sito
                int(self.DATA_LIST[i].area),  #2 - Area
                int(self.DATA_LIST[i].us),  #3 - us
                int(self.DATA_LIST[i].nr_individuo),  #4 -  nr individuo
                str(self.DATA_LIST[i].data_schedatura),  #5 - data schedatura
                str(self.DATA_LIST[i].schedatore),  #6 - schedatore
                str(self.DATA_LIST[i].sesso),  #7 - sesso
                str(self.DATA_LIST[i].eta_min),  #8 - eta' minima
                str(self.DATA_LIST[i].eta_max),  #9- eta massima
                str(self.DATA_LIST[i].classi_eta),  #10 - classi di eta'
                str(self.DATA_LIST[i].osservazioni)  #11 - osservazioni
            ])
        return data_list

    def on_pushButton_pdf_exp_pressed(self):
        Individui_pdf_sheet = generate_pdf()
        data_list = self.generate_list_pdf()
        Individui_pdf_sheet.build_Individui_sheets(data_list)

    def on_pushButton_exp_index_ind_pressed(self):
        Individui_pdf_index = generate_pdf()
        data_list = self.generate_list_pdf()
        Individui_pdf_index.build_index_individui(data_list, data_list[0][0])

    """
	def on_toolButtonPan_toggled(self):
		self.toolPan = QgsMapToolPan(self.mapPreview)
		self.mapPreview.setMapTool(self.toolPan)
	"""
    """
	def on_pushButton_showSelectedFeatures_pressed(self):
		
		field_position = self.pyQGIS.findFieldFrDict(self.ID_TABLE)

		field_list = self.pyQGIS.selectedFeatures()

		id_list_sf = self.pyQGIS.findItemInAttributeMap(field_position, field_list)
		id_list = []
		for idl in id_list_sf:
			sid = idl.toInt()
			id_list.append(sid[0])

		items,order_type = [self.ID_TABLE], "asc"
		self.empty_fields()

		self.DATA_LIST = []
		
		temp_data_list = self.DB_MANAGER.query_sort(id_list, items, order_type, self.MAPPER_TABLE_CLASS, self.ID_TABLE)

		for us in temp_data_list:
			self.DATA_LIST.append(us)

		self.fill_fields()
		self.label_status.setText(self.STATUS["usa"])
		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]
	"""

    #buttons functions
    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_toolButtonGis_toggled(self):
        if self.toolButtonGis.isChecked() == True:
            QMessageBox.warning(
                self, "Messaggio",
                "Modalita' GIS attiva. Da ora le tue ricerche verranno visualizzate sul GIS",
                QMessageBox.Ok)
        else:
            QMessageBox.warning(
                self, "Messaggio",
                "Modalita' GIS disattivata. Da ora le tue ricerche non verranno piu' visualizzate sul GIS",
                QMessageBox.Ok)

    def on_toolButtonPreview_toggled(self):
        if self.toolButtonPreview.isChecked() == True:
            QMessageBox.warning(
                self, "Messaggio",
                "Modalita' Preview US attivata. Le piante delle US saranno visualizzate nella sezione Piante",
                QMessageBox.Ok)
            self.loadMapPreview()
        else:
            self.loadMapPreview(1)

    """
	def on_pushButton_addRaster_pressed(self):
		if self.toolButtonGis.isChecked() == True:
			self.pyQGIS.addRasterLayer()
	"""

    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"], 0)
            self.setComboBoxEnable(["self.comboBox_sito"], "True")
            self.setComboBoxEnable(["self.lineEdit_area"], "True")
            self.setComboBoxEnable(["self.lineEdit_us"], "True")
            self.setComboBoxEnable(["self.lineEdit_individuo"], "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.SORT_STATUS = "n"
                    self.label_sort.setText(
                        self.SORTED_ITEMS[self.SORT_STATUS])
                    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.set_rec_counter(self.REC_TOT, self.REC_CORR + 1)
                    self.setComboBoxEditable(["self.comboBox_sito"], 1)
                    self.setComboBoxEnable(["self.comboBox_sito"], "False")
                    self.setComboBoxEnable(["self.lineEdit_area"], "False")
                    self.setComboBoxEnable(["self.lineEdit_us"], "False")
                    self.setComboBoxEnable(["self.lineEdit_individuo"],
                                           "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.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.lineEdit_area.text())) == 0:
            QMessageBox.warning(
                self, "ATTENZIONE",
                "Campo Area. \n Il campo non deve essere vuoto",
                QMessageBox.Ok)
            test = 1

        if EC.data_is_empty(str(self.lineEdit_us.text())) == 0:
            QMessageBox.warning(self, "ATTENZIONE",
                                "Campo US. \n Il campo non deve essere vuoto",
                                QMessageBox.Ok)
            test = 1

        if EC.data_is_empty(str(self.lineEdit_individuo.text())) == 0:
            QMessageBox.warning(
                self, "ATTENZIONE",
                "Campo nr individuo. \n Il campo non deve essere vuoto",
                QMessageBox.Ok)
            test = 1

        area = self.lineEdit_area.text()
        us = self.lineEdit_us.text()
        nr_individuo = self.lineEdit_individuo.text()
        eta_min = self.comboBox_eta_min.currentText()
        eta_max = self.comboBox_eta_max.currentText()

        if area != "":
            if EC.data_lenght(area, 3) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Area. \n Il valore deve essere lungo massimo 4 caratteri alfanumerici",
                    QMessageBox.Ok)
                test = 1

        if us != "":
            if EC.data_is_int(us) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo US. \n Il valore deve essere di tipo numerico",
                    QMessageBox.Ok)
                test = 1

        if nr_individuo != "":
            if EC.data_is_int(nr_individuo) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Nr individuo. \n Il valore deve essere di tipo numerico",
                    QMessageBox.Ok)
                test = 1

        if eta_min != "":
            if EC.data_is_int(eta_min) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Età minima \n Il valore deve essere di tipo numerico",
                    QMessageBox.Ok)
                test = 1

        if eta_max != "":
            if EC.data_is_int(eta_max) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Età massima \n Il valore deve essere di tipo numerico",
                    QMessageBox.Ok)
                test = 1

        return test

    def insert_new_rec(self):
        if self.comboBox_eta_min.currentText() == "":
            eta_min = None
        else:
            eta_min = int(self.comboBox_eta_min.currentText())

        if self.comboBox_eta_max.currentText() == "":
            eta_max = None
        else:
            eta_max = int(self.comboBox_eta_max.currentText())

        if self.comboBox_classi_eta.currentText() == "":
            classi_eta = ''
        else:
            classi_eta = str(self.comboBox_classi_eta.currentText())

        try:
            data = self.DB_MANAGER.insert_values_ind(
                self.DB_MANAGER.max_num_id(self.MAPPER_TABLE_CLASS,
                                           self.ID_TABLE) + 1,
                str(self.comboBox_sito.currentText()),  #1 - Sito
                str(self.lineEdit_area.text()),  #2 - area
                int(self.lineEdit_us.text()),  #3 - US
                int(self.lineEdit_individuo.text()),  #4 - individuo
                str(self.lineEdit_data_schedatura.text()
                    ),  #5 - data schedatura
                str(self.lineEdit_schedatore.text()),  #6 - schedatore
                str(self.comboBox_sesso.currentText()),  #7 - sesso
                eta_min,  #8 - eta' min
                eta_max,  #9 - eta' max
                classi_eta,  #10 - classi eta
                str(self.textEdit_osservazioni.toPlainText()
                    )  #11 - osservazioni
            )
            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

    #insert new row into tableWidget
    def on_pushButton_insert_row_rapporti_pressed(self):
        self.insert_new_row('self.tableWidget_rapporti')

    def on_pushButton_insert_row_inclusi_pressed(self):
        self.insert_new_row('self.tableWidget_inclusi')

    def on_pushButton_insert_row_campioni_pressed(self):
        self.insert_new_row('self.tableWidget_campioni')

    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, "Messagio!!!", "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.setComboBoxEditable(["self.comboBox_sito"], 1)
                self.setComboBoxEnable(["self.comboBox_sito"], "True")
                self.setComboBoxEnable(["self.lineEdit_area"], "True")
                self.setComboBoxEnable(["self.lineEdit_us"], "True")
                self.setComboBoxEnable(["self.lineEdit_individuo"], "True")
                self.setComboBoxEnable(["self.textEdit_osservazioni"], "False")

                ###
                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:
            if self.lineEdit_us.text() != "":
                us = int(self.lineEdit_us.text())
            else:
                us = ""

            if self.lineEdit_individuo.text() != "":
                individuo = int(self.lineEdit_individuo.text())
            else:
                individuo = ""

            if self.comboBox_eta_min.currentText() != "":
                eta_min = int(self.comboBox_eta_min.currentText())
            else:
                eta_min = ""

            if self.comboBox_eta_max.currentText() != "":
                eta_max = int(self.comboBox_eta_max.currentText())
            else:
                eta_max = ""

            search_dict = {
                self.TABLE_FIELDS[0]:
                "'" + str(self.comboBox_sito.currentText()) + "'",  #1 - Sito
                self.TABLE_FIELDS[1]:
                "'" + str(self.lineEdit_area.text()) + "'",  #2 - Area
                self.TABLE_FIELDS[2]:
                us,  #3 - US
                self.TABLE_FIELDS[3]:
                individuo,  #4 - individuo
                self.TABLE_FIELDS[4]:
                "'" + str(self.lineEdit_data_schedatura.text()) +
                "'",  #5 - data schedatura
                self.TABLE_FIELDS[5]:
                "'" + str(self.lineEdit_schedatore.text()) +
                "'",  #6 - schedatore
                self.TABLE_FIELDS[6]:
                "'" + str(self.comboBox_sesso.currentText()) + "'",  #7 - sesso
                self.TABLE_FIELDS[7]:
                eta_min,  #8 - eta min
                self.TABLE_FIELDS[8]:
                eta_max,  #9 - eta max
                self.TABLE_FIELDS[9]:
                "'" + str(self.comboBox_classi_eta.currentText()) +
                "'",  #10 - classi eta
                self.TABLE_FIELDS[10]:
                str(self.textEdit_osservazioni.toPlainText()
                    )  #11 - osservazioni
            }

            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"], "False")
                    self.setComboBoxEnable(["self.lineEdit_area"], "False")
                    self.setComboBoxEnable(["self.lineEdit_us"], "False")
                    self.setComboBoxEnable(["self.lineEdit_individuo"],
                                           "False")
                    self.setComboBoxEnable(["self.textEdit_osservazioni"],
                                           "True")
                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")
                        if self.toolButtonGis.isChecked() == True:
                            id_us_list = self.charge_id_us_for_individuo()
                            self.pyQGIS.charge_individui_us(id_us_list)
                            self.pyQGIS.charge_individui_from_research(
                                self.DATA_LIST)

                    else:
                        strings = ("Sono stati trovati", self.REC_TOT,
                                   "records")
                        if self.toolButtonGis.isChecked() == True:
                            id_us_list = self.charge_id_us_for_individuo()
                            self.pyQGIS.charge_individui_us(id_us_list)
                            self.pyQGIS.charge_individui_from_research(
                                self.DATA_LIST)

                    self.setComboBoxEnable(["self.comboBox_sito"], "False")
                    self.setComboBoxEnable(["self.lineEdit_area"], "False")
                    self.setComboBoxEnable(["self.lineEdit_us"], "False")
                    self.setComboBoxEnable(["self.lineEdit_individuo"],
                                           "False")
                    self.setComboBoxEnable(["self.textEdit_osservazioni"],
                                           "True")
                    QMessageBox.warning(self, "Messaggio",
                                        "%s %d %s" % strings, QMessageBox.Ok)

        self.enable_button_search(1)

    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 value != None:
                    sub_list.append(str(value.text()))

            if bool(sub_list) == True:
                lista.append(sub_list)

        return lista

    def tableInsertData(self, t, d):
        pass
        """
		self.table_name = t
		self.data_list = ast.literal_eval(d)
		self.data_list.sort()

		#column table count
		table_col_count_cmd = ("%s.columnCount()") % (self.table_name)
		table_col_count = ast.literal_eval(table_col_count_cmd)

		#clear table
		table_clear_cmd = ("%s.clearContents()") % (self.table_name)
		ast.literal_eval(table_clear_cmd)

		for i in range(table_col_count):
			table_rem_row_cmd = ("%s.removeRow(%d)") % (self.table_name, i)
			ast.literal_eval(table_rem_row_cmd)

		#for i in range(len(self.data_list)):
			#self.insert_new_row(self.table_name)
		
		for row in range(len(self.data_list)):
			cmd = ('%s.insertRow(%s)') % (self.table_name, row)
			ast.literal_eval(cmd)
			for col in range(len(self.data_list[row])):
				#item = self.comboBox_sito.setEditText(self.data_list[0][col]
				item = QTableWidgetItem(self.data_list[row][col])
				exec_str = ('%s.setItem(%d,%d,item)') % (self.table_name,row,col)
				ast.literal_eval(exec_str)
		"""

    def insert_new_row(self, table_name):
        """insert new row into a table based on table_name"""
        cmd = table_name + ".insertRow(0)"
        ast.literal_eval(cmd)

    def empty_fields(self):
        #rapporti_row_count = self.tableWidget_rapporti.rowCount()
        #campioni_row_count = self.tableWidget_campioni.rowCount()
        #inclusi_row_count = self.tableWidget_inclusi.rowCount()

        self.comboBox_sito.setEditText("")  #1 - Sito
        self.lineEdit_area.clear()  #2 - area
        self.lineEdit_us.clear()  #3 - US
        self.lineEdit_data_schedatura.clear()  #4 - data schedatura
        self.lineEdit_schedatore.clear()  #5 - schedatore
        self.lineEdit_individuo.clear()  #6 - individuo
        self.comboBox_sesso.setEditText("")  #7 - sesso
        self.comboBox_eta_min.setEditText("")  #8 - eta' minima
        self.comboBox_eta_max.setEditText("")  #9 - eta' massima
        self.comboBox_classi_eta.setEditText("")  #10 - classi di eta'
        self.textEdit_osservazioni.clear()  #11 - osservazioni

    def fill_fields(self, n=0):
        self.rec_num = n
        try:
            self.comboBox_sito.setEditText(
                str(self.DATA_LIST[self.rec_num].sito))  #1 - Sito
            self.lineEdit_area.setText(str(
                self.DATA_LIST[self.rec_num].area))  #2 - area
            self.lineEdit_us.setText(str(
                self.DATA_LIST[self.rec_num].us))  #3 - us
            self.lineEdit_individuo.setText(
                str(self.DATA_LIST[
                    self.rec_num].nr_individuo))  #4 - nr individuo
            self.lineEdit_data_schedatura.setText(
                str(self.DATA_LIST[
                    self.rec_num].data_schedatura))  #5 - data schedatura
            self.lineEdit_schedatore.setText(
                str(self.DATA_LIST[self.rec_num].schedatore))  #6 - schedatore
            self.comboBox_sesso.setEditText(
                str(self.DATA_LIST[self.rec_num].sesso))  #7 - sesso

            if self.DATA_LIST[self.rec_num].eta_min == None:  #8 - eta minima
                self.comboBox_eta_min.setEditText("")
            else:
                self.comboBox_eta_min.setEditText(
                    str(self.DATA_LIST[self.rec_num].eta_min))

            if self.DATA_LIST[self.rec_num].eta_max == None:  #9 - eta massima
                self.comboBox_eta_max.setEditText("")
            else:
                self.comboBox_eta_max.setEditText(
                    str(self.DATA_LIST[self.rec_num].eta_max))

            self.comboBox_classi_eta.setEditText(
                str(self.DATA_LIST[
                    self.rec_num].classi_eta))  #10 - classi di eta

            str(
                self.textEdit_osservazioni.setText(self.DATA_LIST[
                    self.rec_num].osservazioni))  #11 - osservazioni
            if self.toolButtonPreview.isChecked() == True:
                self.loadMapPreview()
        except Exception as e:
            QMessageBox.warning(self, "Errore", str(e), QMessageBox.Ok)

    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):
        if self.comboBox_eta_min.currentText() == "":
            eta_min = None
        else:
            eta_min = self.comboBox_eta_min.currentText()

        if self.comboBox_eta_max.currentText() == "":
            eta_max = None
        else:
            eta_max = self.comboBox_eta_max.currentText()

        #data
        self.DATA_LIST_REC_TEMP = [
            str(self.comboBox_sito.currentText()),  #1 - Sito
            str(self.lineEdit_area.text()),  #2 - Area
            str(self.lineEdit_us.text()),  #3 - US
            str(self.lineEdit_individuo.text()),  #4 - individuo
            str(self.lineEdit_data_schedatura.text()),  #5 - data schedatura
            str(self.lineEdit_schedatore.text()),  #6 - schedatore
            str(self.comboBox_sesso.currentText()),  #7 - sesso
            str(eta_min),  #8- eta minima
            str(eta_max),  #9 - eta massima
            str(self.comboBox_classi_eta.currentText()),  #10 - classi eta
            str(self.textEdit_osservazioni.toPlainText())
        ]  #11 - osservazioni

    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 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 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 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 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 rec_toupdate(self):
        rec_to_update = self.UTILITY.pos_none_in_list(self.DATA_LIST_REC_TEMP)

        #f = open('/test_rec_to_update_ind.txt', 'w')
        #f.write(str(rec_to_update))
        #f.close()

        return rec_to_update

    def charge_id_us_for_individuo(self):
        data_list_us = []
        for rec in range(len(self.DATA_LIST)):
            sito = "'" + str(self.DATA_LIST[rec].sito) + "'"
            area = "'" + str(self.DATA_LIST[rec].area) + "'"
            us = int(self.DATA_LIST[rec].us)

            serch_dict_us = {'sito': sito, 'area': area, 'us': us}
            us_ind = self.DB_MANAGER.query_bool(serch_dict_us, "US")
            data_list_us.append(us_ind)

        data_list_id_us = []
        for us in range(len(data_list_us)):
            data_list_id_us.append(data_list_us[us][0].id_us)

        return data_list_id_us

    def testing(self, name_file, message):
        f = open(str(name_file), 'w')
        f.write(str(message))
        f.close()
コード例 #9
0
class pyarchinit_Upd_Values(QDialog, Ui_DialogSostituisciValori):
    MSG_BOX_TITLE = "PyArchInit - pyarchinit_US_version 0.4 - Aggiornamento Valori"
    DATA_LIST = []
    DATA_LIST_REC_CORR = []
    DATA_LIST_REC_TEMP = []
    REC_CORR = 0
    REC_TOT = 0
    STATUS = {"usa": "Usa", "trova": "Trova", "nuovo_record": "Nuovo Record"}
    SORT_MODE = 'asc'
    SORTED = {"n": "Non ordinati", "o": "Ordinati"}
    UTILITY = Utility()
    DB_MANAGER = ""
    TABLE_NAME = 'us_table'
    MAPPER_TABLE_CLASS = "US"
    NOME_SCHEDA = "Scheda US"
    ID_TABLE = "id_us"
    CONVERSION_DICT = {}
    SORT_ITEMS = []

    TABLE_FIELDS = []

    def __init__(self, iface):
        self.iface = iface
        self.pyQGIS = Pyarchinit_pyqgis(self.iface)

        QDialog.__init__(self)
        self.setupUi(self)
        self.currentLayerId = None
        self.load_connection()

    def load_connection(self):
        from pyarchinit_conn_strings import *

        conn = Connection()
        conn_str = conn.conn_str()
        try:
            self.DB_MANAGER = Pyarchinit_db_management(conn_str)
            self.DB_MANAGER.connection()
        except:
            pass

    def on_pushButton_pressed(self):

        field_position = self.pyQGIS.findFieldFrDict('gid')

        field_list = self.pyQGIS.selectedFeatures()

        id_list_sf = self.pyQGIS.findItemInAttributeMap(
            field_position, field_list)

        id_list = []
        for idl in id_list_sf:
            sid = idl.toInt()
            id_list.append(sid[0])

        table_name = str(self.nome_tabellaLineEdit.text())

        id_field = str(self.campoIDLineEdit.text())

        field_2_upd = str(self.nome_campoLineEdit.text())

        value_2_upd = str(self.sostituisci_conLineEdit.text())

        for i in id_list:
            self.update_record(table_name, id_field, [i], [field_2_upd],
                               [value_2_upd])

    def update_record(self, table_value, id_field_value, id_value_list,
                      table_fields_list, data_list):
        self.DB_MANAGER.update(table_value, id_field_value, id_value_list,
                               table_fields_list, data_list)
コード例 #10
0
class pyarchinit_Upd_Values(QDialog, Ui_DialogSostituisciValori):
	MSG_BOX_TITLE = "PyArchInit - Aggiornamento Valori"
	DATA_LIST = []
	DATA_LIST_REC_CORR = []
	DATA_LIST_REC_TEMP = []
	REC_CORR = 0
	REC_TOT = 0
	STATUS = {"usa": "Usa", "trova": "Trova", "nuovo_record": "Nuovo Record"}
	SORT_MODE = 'asc'
	SORTED = {"n": "Non ordinati", "o": "Ordinati"}
	UTILITY = Utility()
	DB_MANAGER = ""
	TABLE_NAME = 'us_table'
	MAPPER_TABLE_CLASS = "US"
	NOME_SCHEDA = "Scheda US"
	ID_TABLE = "id_us"
	CONVERSION_DICT = {}
	SORT_ITEMS = []
				
	TABLE_FIELDS = []
					

	def __init__(self, iface):
		self.iface = iface
		self.pyQGIS = Pyarchinit_pyqgis(self.iface)

		QDialog.__init__(self)
		self.setupUi(self)
		self.currentLayerId = None
		self.load_connection()


	def load_connection(self):
		from pyarchinit_conn_strings import *

		conn = Connection()
		conn_str = conn.conn_str()
		try:
			self.DB_MANAGER = Pyarchinit_db_management(conn_str)
			self.DB_MANAGER.connection()
		except:
			pass


	def on_pushButton_pressed(self):

		field_position = self.pyQGIS.findFieldFrDict('gid')
		

		field_list = self.pyQGIS.selectedFeatures()


		id_list_sf = self.pyQGIS.findItemInAttributeMap(field_position, field_list)
		
		
		id_list = []
		for idl in id_list_sf:
			sid = idl.toInt()
			id_list.append(sid[0])
			
		
		table_name = str(self.nome_tabellaLineEdit.text())
		
		id_field = str(self.campoIDLineEdit.text())
			
		
		field_2_upd = str(self.nome_campoLineEdit.text())

		value_2_upd = str(self.sostituisci_conLineEdit.text())

		for i in id_list:
			self.update_record(table_name, id_field, [i], [field_2_upd], [value_2_upd])


	def update_record(self, table_value, id_field_value, id_value_list, table_fields_list, data_list):
		self.DB_MANAGER.update(table_value, 
						id_field_value,
						id_value_list,
						table_fields_list,
						data_list)
コード例 #11
0
class pyarchinit_Interactive_Matrix(QDialog, Ui_DialogInteractiveMatrix):
    MSG_BOX_TITLE = "PyArchInit - Scheda Sistema Matrix Interattivo"
    DB_MANAGER = ""
    DATA_LIST = ""
    ID_US_DICT = {}

    if os.name == 'posix':
        HOME = os.environ['HOME']
    elif os.name == 'nt':
        HOME = os.environ['HOMEPATH']

    QUANT_PATH = ('%s%s%s') % (HOME, os.sep,
                               "pyarchinit_Quantificazioni_folder")

    def __init__(self, iface, data_list, id_us_dict):
        self.iface = iface
        self.pyQGIS = Pyarchinit_pyqgis(self.iface)
        self.DATA_LIST = data_list
        self.ID_US_DICT = id_us_dict
        QDialog.__init__(self)
        self.setupUi(self)

        ##		self.textbox.setText('1 2 3 4')
        #self.on_draw()
        try:
            self.DB_connect()
        except:
            pass

    def DB_connect(self):
        from pyarchinit_conn_strings import *
        conn = Connection()
        conn_str = conn.conn_str()
        try:
            self.DB_MANAGER = Pyarchinit_db_management(conn_str)
            self.DB_MANAGER.connection()
        except Exception as e:
            e = str(e)
            QMessageBox.warning(
                self, "Alert",
                "Attenzione rilevato bug! Segnalarlo allo sviluppatore <br> Errore: <br>"
                + str(e), QMessageBox.Ok)

    def generate_matrix(self):
        data = []
        for sing_rec in self.DATA_LIST:
            us = str(sing_rec.us)
            rapporti_stratigrafici = ast.literal_eval(sing_rec.rapporti)
            for sing_rapp in rapporti_stratigrafici:
                try:
                    if sing_rapp[0] == 'Taglia' or sing_rapp[
                            0] == 'Copre' or sing_rapp[
                                0] == 'Si appoggia a' or sing_rapp[
                                    0] == 'Riempie' or sing_rapp[
                                        0] == 'Si lega a' or sing_rapp[
                                            0] == 'Uguale a':
                        if sing_rapp[1] != '':
                            harris_rapp = (us, str(sing_rapp[1]))
                            data.append(harris_rapp)
                except Exception as e:
                    QMessageBox.warning(
                        self, "Messaggio",
                        "Problema nel sistema di esportazione del Matrix:" +
                        str(e), QMessageBox.Ok)

        sito = self.DATA_LIST[0].sito

        search_dict = {'sito': "'" + str(sito) + "'"}

        periodizz_data_list = self.DB_MANAGER.query_bool(
            search_dict, 'PERIODIZZAZIONE')

        periodi_data_values = []
        for i in periodizz_data_list:
            periodi_data_values.append([i.periodo, i.fase])

        periodi_us_list = []

        clust_number = 0
        for i in periodi_data_values:
            search_dict = {
                'sito': "'" + str(sito) + "'",
                'periodo_iniziale': "'" + str(i[0]) + "'",
                'fase_iniziale': "'" + str(i[1]) + "'"
            }

            us_group = self.DB_MANAGER.query_bool(search_dict, 'US')

            cluster_label = "cluster%d" % (clust_number)

            periodo_label = "Periodo %s - Fase %s" % (str(i[0]), str(i[1]))

            sing_per = [cluster_label, periodo_label]

            sing_us = []
            for rec in us_group:
                sing_us.append(rec.us)

            sing_per.insert(0, sing_us)

            periodi_us_list.append(sing_per)

            clust_number += 1

        matrix_exp = HARRIS_MATRIX_EXP(data, periodi_us_list)
        data_plotting = matrix_exp.export_matrix()

        return data_plotting

        QMessageBox.warning(self, "Messaggio",
                            "Esportazione del Matrix terminata",
                            QMessageBox.Ok)

    def plot_matrix(self, dp):
        self.data_plot = dp

        G1 = nx.DiGraph(self.data_plot)  # now make it a Graph
        #G1.write_dot(G1,'test.dot')
        #nx.write_dot(G1,'test.dot')
        #plt.title("draw_networkx")
        pos = nx.graphviz_layout(G1, prog='dot')
        #fig = plt.figure()

        #self.widgetMatrix.canvas.ax = self.fig.add_subplot(111)

        self.widgetMatrix.canvas.ax.set_title(
            'click su una US per disegnarla a video', picker=True)
        self.widgetMatrix.canvas.ax.set_ylabel('ylabel',
                                               picker=True,
                                               bbox=dict(facecolor='red'))

        points = []
        key = []
        for k, v in list(pos.items()):
            key.append(k)
            points.append(v)

        for i in range(len(key)):
            self.widgetMatrix.canvas.ax.text(points[i][0],
                                             points[i][1],
                                             key[i],
                                             picker=True,
                                             ha='center',
                                             alpha=0)

        self.widgetMatrix.canvas.ax.plot(nx.draw(G1,
                                                 pos,
                                                 with_labels=True,
                                                 arrows=True,
                                                 node_color='w',
                                                 node_shape='s',
                                                 node_size=400),
                                         'o',
                                         picker=1000)

        #self.widgetMatrix.canvas.fig.canvas.mpl_connect('pick_event', self.on_pick)
        self.widgetMatrix.canvas.mpl_connect('pick_event', self.on_pick)
        self.widgetMatrix.canvas.draw()

    def on_pick(self, event):
        # The event received here is of the type
        # matplotlib.backend_bases.PickEvent
        #.canvas
        # It carries lots of information, of which we're using
        # only a small amount here.
        # 		def onpick1(event):
        #if isinstance(event.artist, Text):
        text = event.artist
        value = text.get_prop_tup()
        text_to_pass = value[2]
        ##				print('Hai selezionato l\'US:', text.get_text())
        ##		box_points = event.artist.get_bbox().get_points()
        idus = self.ID_US_DICT[int(text_to_pass)]
        self.pyQGIS.charge_vector_layers_from_matrix(idus)
        #msg = "'Hai selezionato l\'US:' %s" % text_to_pass #str(dir(text.get_label))

        #QMessageBox.information(self, "Click!", msg)

    def testing(self, name_file, message):
        f = open(str(name_file), 'w')
        f.write(str(message))
        f.close()
コード例 #12
0
class pyarchinit_Periodizzazione(QDialog, Ui_DialogPeriodoFase):
    MSG_BOX_TITLE = "PyArchInit - Scheda Periodizzazione"
    DATA_LIST = []
    DATA_LIST_REC_CORR = []
    DATA_LIST_REC_TEMP = []
    REC_CORR = 0
    REC_TOT = 0
    BROWSE_STATUS = "b"
    STATUS_ITEMS = {"b": "Usa", "f": "Trova", "n": "Nuovo Record"}
    SORT_MODE = 'asc'
    SORTED_ITEMS = {"n": "Non ordinati", "o": "Ordinati"}
    SORT_STATUS = "n"
    UTILITY = Utility()
    DB_MANAGER = ""
    TABLE_NAME = 'periodizzazione_table'
    MAPPER_TABLE_CLASS = "PERIODIZZAZIONE"
    NOME_SCHEDA = "Scheda Periodizzazione"
    ID_TABLE = "id_perfas"
    CONVERSION_DICT = {
        ID_TABLE: ID_TABLE,
        "Sito": "sito",
        "Periodo": "periodo",
        "Fase": "fase",
        "Cronologia iniziale": "cron_iniziale",
        "Cronologia finale": "cron_finale",
        "Descrizione": "descrizione",
        "Datazione estesa": "datazione_estesa",
        "Codice periodo": "cont_per"
    }
    SORT_ITEMS = [
        ID_TABLE, "Sito", "Periodo", "Fase", "Descrizione",
        "Cronologia iniziale", "Cronologia finale", "Codice periodo"
    ]

    TABLE_FIELDS = [
        'sito', 'periodo', 'fase', 'cron_iniziale', 'cron_finale',
        'descrizione', 'datazione_estesa', 'cont_per'
    ]

    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:
            pass

    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_sito()
                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_sito()
                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",
                    QMessageBox.Ok)
            else:
                QMessageBox.warning(
                    self, "Alert",
                    "Attenzione rilevato bug! Segnalarlo allo sviluppatore<br> Errore: <br>"
                    + str(e), QMessageBox.Ok)

    def charge_list(self):
        pass

    def charge_list_sito(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.clear()
        sito_vl.sort()
        self.comboBox_sito.addItems(sito_vl)

    def on_pushButton_pdf_scheda_exp_pressed(self):
        Periodizzazione_pdf_sheet = generate_Periodizzazione_pdf(
        )  #deve essere importata la classe
        data_list = self.generate_list_pdf()  #deve essere aggiunta la funzione
        Periodizzazione_pdf_sheet.build_Periodizzazione_sheets(
            data_list)  #deve essere aggiunto il file per generare i pdf

    def on_pushButton_pdf_lista_exp_pressed(self):
        Periodizzazione_pdf_list = generate_Periodizzazione_pdf(
        )  #deve essere importata la classe
        data_list = self.generate_list_pdf()  #deve essere aggiunta la funzione
        Periodizzazione_pdf_list.build_index_Periodizzazione(
            data_list,
            data_list[0][0])  #deve essere aggiunto il file per generare i pdf

        #codice per l'esportazione sperimentale dei PDF #
        """
		dlg = pyarchinit_PDFAdministrator()
		dlg.set_table_name(self.TABLE_NAME)
		dlg.connect()
		msg = QMessageBox.warning(self,'ATTENZIONE',"Vuoi creare un nuovo layout PFD?", QMessageBox.Cancel,1)
		dlg.connect()
		##		dlg.on_pushButton_connect_pressed()
		if msg == 1:
			dlg.on_pushButton_new_rec_pressed()
			dlg.charge_list()
		
		id_list = []

		for i in self.DATA_LIST:
			id_list.append(ast.literal_eval("i." + self.ID_TABLE))
		dlg.add_id_list(id_list)

		dlg.exec_()
		"""

    def generate_list_pdf(self):
        periodo = ""
        fase = ""
        cron_iniz = ""
        cron_fin = ""

        data_list = []
        for i in range(len(self.DATA_LIST)):

            if self.DATA_LIST[i].periodo == None:
                periodo = ""
            else:
                periodo = str(self.DATA_LIST[i].periodo)

            if self.DATA_LIST[i].fase == None:
                fase = ""
            else:
                fase = str(self.DATA_LIST[i].fase)

            if self.DATA_LIST[i].cron_iniziale == None:
                cron_iniz = ""
            else:
                cron_iniz = str(self.DATA_LIST[i].cron_iniziale)

            if self.DATA_LIST[i].cron_finale == None:
                cron_fin = ""
            else:
                cron_fin = str(self.DATA_LIST[i].cron_finale)

            data_list.append([
                str(self.DATA_LIST[i].sito),  #1 - Sito
                str(periodo),  #2 - periodo
                str(fase),  #3 - fase
                str(cron_iniz),  #4 - cron iniz
                str(cron_fin),  #5 - cron fin
                str(self.DATA_LIST[i].datazione_estesa),  #6 - datazione_estesa
                str(self.DATA_LIST[i].descrizione)  #7 - descrizione
            ])
        return data_list

    #buttons functions
    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))

        if self.BROWSE_STATUS != "n":
            self.BROWSE_STATUS = "n"

            ###

            self.setComboBoxEditable(["self.comboBox_sito"], 0)
            self.setComboBoxEditable(["self.comboBox_periodo"], 0)
            self.setComboBoxEditable(["self.comboBox_fase"], 0)
            self.setComboBoxEnable(["self.comboBox_sito"], "True")
            self.setComboBoxEnable(["self.comboBox_periodo"], "True")
            self.setComboBoxEnable(["self.comboBox_fase"], "True")

            ###
            self.label_sort.setText(self.SORTED_ITEMS[self.SORT_STATUS])

            self.label_status.setText(self.STATUS_ITEMS[self.BROWSE_STATUS])
            self.set_rec_counter('', '')
            self.label_sort.setText(self.SORTED_ITEMS["n"])
            self.empty_fields()

            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.SORT_STATUS = "n"
                    self.label_sort.setText(
                        self.SORTED_ITEMS[self.SORT_STATUS])
                    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.SORT_STATUS = "n"
                    self.label_sort.setText(
                        self.SORTED_ITEMS[self.SORT_STATUS])
                    self.charge_records()
                    self.charge_list()
                    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"], 1)
                    self.setComboBoxEditable(["self.comboBox_periodo"], 1)
                    self.setComboBoxEditable(["self.comboBox_fase"], 1)
                    self.setComboBoxEnable(["self.comboBox_sito"], "False")
                    self.setComboBoxEnable(["self.comboBox_periodo"], "False")
                    self.setComboBoxEnable(["self.comboBox_fase"], "False")
                    self.fill_fields(self.REC_CORR)
                    self.enable_button(1)
            else:
                QMessageBox.warning(self, "ATTENZIONE",
                                    "Problema nell'inserimento dati",
                                    QMessageBox.Ok)

    def data_error_check(self):
        test = 0
        EC = Error_check()

        data_estesa = self.lineEdit_per_estesa.text()

        if data_estesa != "":
            if EC.data_lenght(data_estesa, 299) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Datazione estesa. \n non deve superare i 300 caratteri alfanumerici",
                    QMessageBox.Ok)
                test = 1

        periodo = self.comboBox_periodo.currentText()
        cron_iniz = self.lineEdit_cron_iniz.text()
        cron_fin = self.lineEdit_cron_fin.text()
        cod_per = self.lineEdit_codice_periodo.text()

        if periodo != "":
            if EC.data_is_int(periodo) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Periodo. \n Il valore deve essere di tipo numerico",
                    QMessageBox.Ok)
                test = 1

        if cron_iniz != "":
            if EC.data_is_int(cron_iniz) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Cronologia Iniziale. \n Il valore deve essere di tipo numerico",
                    QMessageBox.Ok)
                test = 1

        if cron_fin != "":
            if EC.data_is_int(cron_fin) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Cronologia Finale. \n Il valore deve essere di tipo numerico",
                    QMessageBox.Ok)
                test = 1

        if cod_per != "":
            if EC.data_is_int(cod_per) == 0:
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Campo Codice Periodo \n Il valore deve essere di tipo numerico",
                    QMessageBox.Ok)
                test = 1

        return test

    def insert_new_rec(self):
        cont_per = 0
        try:
            if self.lineEdit_cron_iniz.text() == "":
                cron_iniz = None
            else:
                cron_iniz = int(self.lineEdit_cron_iniz.text())

            if self.lineEdit_cron_fin.text() == "":
                cron_fin = None
            else:
                cron_fin = int(self.lineEdit_cron_fin.text())

            if self.lineEdit_codice_periodo.text() == "":
                cont_per = None
            else:
                cont_per = int(self.lineEdit_codice_periodo.text())

            data = self.DB_MANAGER.insert_periodizzazione_values(
                self.DB_MANAGER.max_num_id(self.MAPPER_TABLE_CLASS,
                                           self.ID_TABLE) + 1,  #0 - max num id
                str(self.comboBox_sito.currentText()),  #1 - Sito
                int(self.comboBox_periodo.currentText()),  #2 - Periodo
                int(self.comboBox_fase.currentText()),  #3 - Fase
                cron_iniz,  #4 - Cron iniziale
                cron_fin,  #5 - Cron finale
                str(self.textEdit_descrizione_per.toPlainText()
                    ),  #6 - Descrizione
                str(self.lineEdit_per_estesa.text()
                    ),  #7 - Periodizzazione estesa
                cont_per)  #8 - Cont_per

            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",
                                    "immisione 1 \n" + str(msg),
                                    QMessageBox.Ok)
                return 0
        except Exception as e:
            QMessageBox.warning(self, "Errore",
                                "Errore di immissione 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, "Messagio!!!", "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)

            self.setComboBoxEditable(["self.comboBox_sito"], 1)

            #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.empty_fields()
                self.set_rec_counter('', '')
                self.label_sort.setText(self.SORTED_ITEMS["n"])

                self.setComboBoxEditable(["self.comboBox_sito"], 1)
                self.setComboBoxEditable(["self.comboBox_periodo"], 1)
                self.setComboBoxEditable(["self.comboBox_fase"], 1)
                self.setComboBoxEnable(["self.comboBox_sito"], "True")
                self.setComboBoxEnable(["self.comboBox_periodo"], "True")
                self.setComboBoxEnable(["self.comboBox_fase"], "True")
                self.setComboBoxEnable(["self.textEdit_descrizione_per"],
                                       "False")

    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:
            if self.lineEdit_cron_iniz.text() != "":
                cron_iniziale = "'" + str(self.lineEdit_cron_iniz.text()) + "'"
            else:
                cron_iniziale = ""

            if self.lineEdit_cron_fin.text() != "":
                cron_finale = "'" + str(self.lineEdit_cron_fin.text()) + "'"
            else:
                cron_finale = ""

            if self.comboBox_periodo.currentText() != "":
                periodo = "'" + str(self.comboBox_periodo.currentText()) + "'"
            else:
                periodo = ""

            if self.comboBox_fase.currentText() != "":
                fase = "'" + str(self.comboBox_fase.currentText()) + "'"
            else:
                fase = ""

            search_dict = {
                'sito':
                "'" + str(self.comboBox_sito.currentText()) + "'",  #1 - Sito
                'periodo': periodo,  #2 - Periodo
                'fase': fase,  #3 - Fase
                'cron_iniziale': cron_iniziale,  #4 - Cron iniziale
                'cron_finale': cron_finale,  #5 - Crion finale
                'descrizione': str(self.textEdit_descrizione_per.toPlainText()
                                   ),  #6 - Descrizione
                'datazione_estesa':
                "'" + str(self.lineEdit_per_estesa.text()) +
                "'",  #7 - Periodizzazione estesa
                'cont_per': "'" + str(self.lineEdit_codice_periodo.text()) +
                "'"  #8 - Codice periodo
            }

            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.setComboBoxEditable(["self.comboBox_sito"], 1)
                    self.setComboBoxEditable(["self.comboBox_periodo"], 1)
                    self.setComboBoxEditable(["self.comboBox_fase"], 1)

                    self.setComboBoxEnable(["self.comboBox_sito"], "False")
                    self.setComboBoxEnable(["self.comboBox_periodo"], "False")
                    self.setComboBoxEnable(["self.comboBox_fase"], "False")

                    self.setComboBoxEnable(["self.textEdit_descrizione_per"],
                                           "True")

                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.setComboBoxEditable(["self.comboBox_sito"], 1)
                    self.setComboBoxEditable(["self.comboBox_periodo"], 1)
                    self.setComboBoxEditable(["self.comboBox_fase"], 1)
                    self.setComboBoxEnable(["self.comboBox_sito"], "False")
                    self.setComboBoxEnable(["self.comboBox_periodo"], "False")
                    self.setComboBoxEnable(["self.comboBox_fase"], "False")
                    self.setComboBoxEnable(["self.textEdit_descrizione_per"],
                                           "True")

                    QMessageBox.warning(self, "Messaggio",
                                        "%s %d %s" % strings, QMessageBox.Ok)

        self.enable_button_search(1)

    def on_pushButton_show_periodo_pressed(self):
        if self.lineEdit_codice_periodo.text() == "":
            QMessageBox.warning(self, "Messaggio",
                                "Codice periodo non assegnato", QMessageBox.Ok)
        else:
            sito_p = self.comboBox_sito.currentText()
            cont_per = self.lineEdit_codice_periodo.text()
            per_label = self.comboBox_periodo.currentText()
            fas_label = self.comboBox_fase.currentText()
            self.pyQGIS.charge_vector_layers_periodo(sito_p, int(cont_per),
                                                     per_label, fas_label)

    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 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 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 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.setEditText("")  #1 - Sito
        self.comboBox_periodo.setEditText("")  #2 - Periodo
        self.comboBox_fase.setEditText("")  #3 - Fase
        self.lineEdit_cron_iniz.clear()  #4 - Cronologia iniziale
        self.lineEdit_cron_fin.clear()  #5 - Cronologia finale
        self.lineEdit_per_estesa.clear()  #6 - Datazione estesa
        self.textEdit_descrizione_per.clear()  #7 - Descrizione
        self.lineEdit_codice_periodo.clear()  #8 - Codice periodo

    def fill_fields(self, n=0):
        self.rec_num = n
        try:
            str(
                self.comboBox_sito.setEditText(
                    self.DATA_LIST[self.rec_num].sito))  #1 - Sito

            self.comboBox_periodo.setEditText(
                str(self.DATA_LIST[self.rec_num].periodo))  #2 - Periodo
            self.comboBox_fase.setEditText(
                str(self.DATA_LIST[self.rec_num].fase))  #3 - Fase

            if self.DATA_LIST[
                    self.
                    rec_num].cron_iniziale == None:  #4 - Cronologia iniziale
                self.lineEdit_cron_iniz.setText("")
            else:
                self.lineEdit_cron_iniz.setText(
                    str(self.DATA_LIST[self.rec_num].cron_iniziale))

            if self.DATA_LIST[
                    self.rec_num].cron_finale == None:  #5 - Cronologia finale
                self.lineEdit_cron_fin.setText("")
            else:
                self.lineEdit_cron_fin.setText(
                    str(self.DATA_LIST[self.rec_num].cron_finale))

            str(
                self.lineEdit_per_estesa.setText(self.DATA_LIST[
                    self.rec_num].datazione_estesa))  #6 - Datazione estesa
            str(
                self.textEdit_descrizione_per.setText(self.DATA_LIST[
                    self.rec_num].descrizione))  #7 - Descrizione

            if self.DATA_LIST[
                    self.rec_num].cont_per == None:  #8 - Codice periodo
                self.lineEdit_codice_periodo.setText("")
            else:
                self.lineEdit_codice_periodo.setText(
                    str(self.DATA_LIST[self.rec_num].cont_per))

        except Exception as e:
            QMessageBox.warning(self, "Errore Fill Fields", str(e),
                                QMessageBox.Ok)

    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
        if self.lineEdit_cron_iniz.text() == "":
            cron_iniz = None
        else:
            cron_iniz = str(self.lineEdit_cron_iniz.text())

        if self.lineEdit_cron_fin.text() == "":
            cron_fin = None
        else:
            cron_fin = str(self.lineEdit_cron_fin.text())

        if self.lineEdit_codice_periodo.text() == "":
            cont_per = None
        else:
            cont_per = str(self.lineEdit_codice_periodo.text())

        self.DATA_LIST_REC_TEMP = [
            str(self.comboBox_sito.currentText()),  #1 - Sito
            str(self.comboBox_periodo.currentText()),  #2 - Periodo
            str(self.comboBox_fase.currentText()),  #3 - Fase
            str(cron_iniz),  #4 - Cron iniziale
            str(cron_fin),  #5 - Cron finale
            str(self.textEdit_descrizione_per.toPlainText()
                ),  #6 - Descrizioene
            str(self.lineEdit_per_estesa.text()),  #7 - Cron estesa
            str(cont_per)
        ]  #8 - Cont_per

    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 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 rec_toupdate(self):
        rec_to_update = self.UTILITY.pos_none_in_list(self.DATA_LIST_REC_TEMP)
        return rec_to_update

    def testing(self, name_file, message):
        f = open(str(name_file), 'w')
        f.write(str(message))
        f.close()