def killa_sessione(p_sid, p_serial, p_oracle_user_sys, p_oracle_password_sys, p_oracle_dsn_real): """ killa la sessione oracle dalla coppia p_sid e p_serial """ if message_question_yes_no( "Do you want to kill the selected session?") == 'Yes': try: # connessione al DB come amministratore v_connection = cx_Oracle.connect(user=p_oracle_user_sys, password=p_oracle_password_sys, dsn=p_oracle_dsn_real, mode=cx_Oracle.SYSDBA) v_ok = True except: message_error( 'Connection to oracle rejected. Please control login information.' ) v_ok = False if v_ok: v_cursor = v_connection.cursor() v_cursor.execute("ALTER SYSTEM KILL SESSION '" + str(p_sid).strip() + "," + str(p_serial).strip() + "'") v_cursor.close() v_connection.close() message_info('The session is being closed.')
def b_save_slot(self): """ Salva i parametri di ricerca """ self.o_preferenze.stringa1 = self.e_stringa1.displayText() self.o_preferenze.stringa2 = self.e_stringa2.displayText() self.o_preferenze.pathname = self.e_pathname.displayText() self.o_preferenze.excludepath = self.e_excludepath.displayText() self.o_preferenze.outputfile = self.e_outputfile.displayText() self.o_preferenze.filter = self.e_filter.displayText() if self.c_flsearch.isChecked(): self.o_preferenze.flsearch = True else: self.o_preferenze.flsearch = False self.o_preferenze.dboracle1 = self.e_dboracle1.displayText() self.o_preferenze.dboracle2 = self.e_dboracle2.displayText() if self.c_dbsearch.isChecked(): self.o_preferenze.dbsearch = True else: self.o_preferenze.dbsearch = False if self.c_icomsearch.isChecked(): self.o_preferenze.icomsearch = True else: self.o_preferenze.icomsearch = False self.o_preferenze.salva() message_info('Search options saved!')
def slot_actionFactory_reset(self): """ Ritorna alle preferenze di base eliminando la directory di lavoro. Al termine il programma viene chiuso senza salvare """ if message_question_yes_no('Do you want delete the preferences files in folder ' + self.o_preferenze.work_dir + '?') == 'Yes': if message_question_yes_no('Are you sure?') == 'Yes': self.o_preferenze.cancella_tutto() message_info('Preferences files deleted! Close and restart the program!')
def b_save_slot(self): """ Salva i parametri di ricerca """ self.o_preferenze.filesearch = self.e_filesearch.displayText() self.o_preferenze.pathname2 = self.e_pathname.displayText() self.o_preferenze.excludepath2 = self.e_excludepath.displayText() self.o_preferenze.filter2 = self.e_filter.displayText() self.o_preferenze.salva() message_info('Search options saved!')
def slot_log_session(self, event): """ crea un file riportante le informazioni di sessione (al momento i cursori aperti) """ # ottengo un oggetto index-qt della riga selezionata index = self.o_lst1.currentIndex() # non devo prendere la cella selezionata ma la cella 0 e 1 della riga selezionata (esse contengono sid e serial nr della sessione) v_item_0 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 0)) v_item_1 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 1)) v_sid = v_item_0.text() v_serial_n = v_item_1.text() # apro il file dei risultati v_file_name = os.path.join(self.o_preferenze.work_dir, 'session_information.sql') v_file = open(v_file_name, 'w') try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return None # apro cursore v_cursor = v_connection.cursor() # select per la ricerca dei cursori aperti e relativo sql v_select = "SELECT sql_text FROM v$sql WHERE hash_value IN (SELECT hash_value FROM v$open_cursor WHERE SID=" + str( v_sid) + ") GROUP BY sql_text" v_cursor.execute(v_select) for result in v_cursor: # scrivo i risultati nel file v_file.write(result[0] + '\n') v_cursor.close() v_connection.close() v_file.close() message_info(v_file_name + ' created!') # apre il file appena creato os.startfile(v_file_name)
def slot_b_start_download(self): """ esegue il download dell'oggetto indicato """ if self.e_source.displayText() == '': message_error('You must enter a source file name with suffix!') return None if self.e_destination_dir.displayText() == '': message_error('You must enter a destination dir!') return None # controllo che il file di destinazione non esista; questo perché al termine del download solo controllando la presenza del file # potrò dire che il download è stato correttamente eseguito v_sorgente = self.e_source.displayText() v_destinazione = os.path.join(self.e_destination_dir.displayText() + '/' + v_sorgente) if os.path.isfile(v_destinazione): message_error("Destination file already exists!") return None #imposto i nomi dei file su cui ridirigere output dei comandi (in questo modo non escono le brutte window di dos) v_sshoutput = open( os.path.join(self.o_preferenze.work_dir, 'sshoutput.txt'), 'w') v_sshoutputerror = open( os.path.join(self.o_preferenze.work_dir, 'sshoutputerror.txt'), 'w') v_sshinput = '' # eseguo il download try: # scarico il file nella directory indicata v_ip = '10.0.4.14' v_pwd = self.o_preferenze.v_server_password_iAS v_command = 'echo y | utility_prog\\pscp -pw ' + v_pwd + ' oracle@' + v_ip + ':/appl/source/' + v_sorgente + ' ' + v_destinazione v_ssh = subprocess.Popen(v_command, shell=True, stdin=subprocess.PIPE, stdout=v_sshoutput, stderr=v_sshoutputerror) v_ssh.communicate(v_sshinput) # controllo se il file è stato effettivamente scaricato if os.path.isfile(v_destinazione): message_info('Download finished!') else: message_error('Error to download ' + self.e_source.displayText() + '!') except: message_error('Error to download ' + self.e_source.displayText() + '!') return None
def slot_startjob(self): """ Avvia un job """ if hasattr(self, 'lista_risultati'): # ottengo un oggetto index-qt della riga selezionata index = self.o_lst1.currentIndex() # non devo prendere la cella selezionata ma la cella 0 della riga selezionata (quella che contiene il nome del job) v_item_0 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 0)) if v_item_0 != None: v_job_name = v_item_0.text() if message_question_yes_no( 'Do you want start ' + v_job_name + ' job?\nNotice! MGrep will be waiting the end of job!' ) == 'Yes': try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] # apro cursore v_cursor = v_connection.cursor() # imposto l'istruzione v_istruzione = "BEGIN DBMS_SCHEDULER.RUN_JOB (job_name => 'SMILE." + v_job_name + "'); END;" # eseguo istruzione monitorando eventuali errori (attivo l'icona della clessidra) try: QtWidgets.QApplication.setOverrideCursor( QtGui.QCursor(QtCore.Qt.WaitCursor)) v_cursor.execute(v_istruzione) QtWidgets.QApplication.restoreOverrideCursor() message_info('Job finished :-)') # se riscontrato errore --> emetto sia codice che messaggio except cx_Oracle.Error as e: errorObj, = e.args message_error("Error: " + errorObj.message) # chiudo e disattivo icona della clessidra v_cursor.close() v_connection.close() QtWidgets.QApplication.restoreOverrideCursor()
def __init__(self, p_user_db, p_password_db, p_dsn_db, p_table_name, p_table_where, p_sqlite_db_name, p_blob_pathname, p_modalita_test): # rendo la mia classe una superclasse super(copy_from_oracle_to_sqlite, self).__init__() # completo la pathname p_blob_pathname = p_blob_pathname + '\\' # creazione della wait window self.v_progress_step = 0 self.progress = QtWidgets.QProgressDialog(self) self.progress.setMinimumDuration(0) self.progress.setWindowModality(QtCore.Qt.WindowModal) self.progress.setWindowTitle("Copy...") # icona di riferimento icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/icons/MGrep.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.progress.setWindowIcon(icon) # imposto valore minimo e massimo a 0 in modo venga considerata una progress a tempo indefinito # Attenzione! dentro nel ciclo deve essere usata la funzione setvalue altrimenti non visualizza e non avanza nulla! self.progress.setMinimum(0) self.progress.setMaximum(100) # creo un campo label che viene impostato con 100 caratteri in modo venga data una dimensione di base standard self.progress_label = QtWidgets.QLabel() self.progress_label.setText('.'*100) # collego la label già presente nell'oggetto progress bar con la mia label self.progress.setLabel(self.progress_label) # creo una scritta iniziale... self.avanza_progress('Collecting data...') # copia tabella if self.copia_tabella(p_user_db, p_password_db, p_dsn_db, p_table_name, p_table_where, p_sqlite_db_name, p_blob_pathname) == 'ok': message_info('Table copy completed!') self.progress.close() self.close()
def slot_enablejob(self): """ Riattiva un job """ if hasattr(self, 'lista_risultati'): # ottengo un oggetto index-qt della riga selezionata index = self.o_lst1.currentIndex() # non devo prendere la cella selezionata ma la cella 0 della riga selezionata (quella che contiene il nome del job) v_item_0 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 0)) if v_item_0 != None: v_job_name = v_item_0.text() if message_question_yes_no('Do you want enable ' + v_job_name + ' job?') == 'Yes': try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] # apro cursore v_cursor = v_connection.cursor() # imposto l'istruzione v_istruzione = "BEGIN DBMS_SCHEDULER.ENABLE (name => 'SMILE." + v_job_name + "'); END;" # eseguo istruzione monitorando eventuali errori try: v_cursor.execute(v_istruzione) message_info(v_job_name + ' was enabled!') # se riscontrato errore --> emetto sia codice che messaggio except cx_Oracle.Error as e: errorObj, = e.args message_error("Error: " + errorObj.message) # chiudo v_cursor.close() v_connection.close()
def __init__(self): super(MGrep_class, self).__init__() self.setupUi(self) # carico le preferenze self.o_preferenze = preferenze() self.o_preferenze.carica() # se nelle preferenze non risultano caricate le password dei server --> avviso if self.o_preferenze.v_oracle_password_sys == '' or self.o_preferenze.v_server_password_DB == '' or self.o_preferenze.v_server_password_iAS == '': message_info('Password files not found! The Oracle functions will be not accessibled!') # se dalle preferenze emerge che vanno aperte delle window in una certa posizione, procedo con apertura self.apre_finestre_salvate() # l'attributo frozen viene attivato quando il programma viene compilato; quindi, # quando il programma viene eseguito onsite, evenutali errori non controllati vengono reindirizzati # verso specifici file di testo presenti nella directory di lavoro sys.stdout = my_console(self.o_preferenze.work_dir + '\\MGrep_stdout.txt') sys.stderr = my_console(self.o_preferenze.work_dir + '\\MGrep_stderr.txt')
def slot_b_save(self): """ Salva le preferenze """ self.o_preferenze.dboracle = self.e_dboracle.currentText() self.o_preferenze.sqlite_db = self.e_sqlite_db.text() self.o_preferenze.where_cond = self.e_where_cond.toPlainText() self.o_preferenze.table_name = self.e_table_name.currentText() self.o_preferenze.table_excel = self.e_table_excel.currentText() self.o_preferenze.excel_file = self.e_excel_file.text() self.o_preferenze.table_to_oracle = self.e_table_to_oracle.currentText( ) self.o_preferenze.import_excel = self.e_import_excel.text() self.o_preferenze.oracle_table = self.e_oracle_table.currentText() self.o_preferenze.csv_file = self.e_csv_file.text() self.o_preferenze.csv_separator = self.e_csv_separator.text() self.o_preferenze.salva() message_info('Preferences was saved')
def slot_backup_line(self): """ Copia il file indicato all'interno di un file zip di nome Old, presente nella medesima cartella del file di partenza. Se il file zip non esiste, viene creato. Se esiste il file indicato viene accodato """ if message_question_yes_no( "Do you want to backup file into old.zip?") == 'Yes': # ricerco la posizione dell'indice selezionato e ne ricavo il contenuto try: v_index = self.o_lst1.selectedIndexes()[0] except: return v_item = self.lista_risultati.itemFromIndex(v_index) v_seltext = v_item.text() #scompongo l'intera pathname in tutte le sue componenti (directory, nome file, suffisso) v_directory = os.path.split(v_seltext)[0] v_solo_nome_file = os.path.split(v_seltext)[1] v_solo_nome_file_senza_suffisso = os.path.splitext( v_solo_nome_file)[0] v_suffisso_nome_file = os.path.splitext(v_solo_nome_file)[1] #prendo la data di sistema che servirà per dare un suffisso al nome del file che viene zippato v_system_date = datetime.datetime.now() v_str_data = '_' + str(v_system_date.year) + '_' + str( v_system_date.month) + '_' + str(v_system_date.day) if v_directory != '': try: #apro il file zip (se non esiste lo creo) v_zip = zipfile.ZipFile(v_directory + '\\old.zip', 'a') #accodo il file indicato allo zip (il nome di arrivo è il nome del file più suffisso data) v_zip.write( v_seltext, v_solo_nome_file_senza_suffisso + v_str_data + '.' + v_suffisso_nome_file) #chiudo lo zip e emetto messaggio che procedura terminata v_zip.close() message_info('The file ' + v_solo_nome_file + ' is been copied into Old.zip') except: message_error('Error to copy the file into Old zip!')
def slot_b_compile_all(self): """ compila tutti gli oggetti invalidi """ try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) v_error = False except: message_error( 'Connection to oracle rejected. Please control login information.' ) v_error = True if not v_error: # imposto l'icona della freccia del cursore a waiting QtWidgets.QApplication.setOverrideCursor( QtGui.QCursor(QtCore.Qt.WaitCursor)) # apro cursori v_cursor = v_connection.cursor() # esecuzione dello script che ricompila tutti gli oggetti invalidi v_cursor.execute("BEGIN UTL_RECOMP.RECOMP_SERIAL(); END;") v_cursor.close() v_connection.close() # select per la ricerca degli oggetti invalidi self.slot_b_search_all() # tolgo icona freccia cursore e lo riporto a normale ed emetto messaggio di fine QtWidgets.QApplication.restoreOverrideCursor() message_info('Invalid objects recompiled!')
def __init__(self, p_sorgente, p_work_dir, p_tipo): # rendo la mia classe una superclasse super(pubblica_form_report, self).__init__() # carico le preferenze self.o_preferenze = preferenze() self.o_preferenze.carica() # creazione della wait window self.v_progress_step = 0 self.progress = QtWidgets.QProgressDialog(self) self.progress.setMinimumDuration(0) self.progress.setWindowModality(QtCore.Qt.WindowModal) self.progress.setWindowTitle("Pubblication on server iAS12g") # icona di riferimento icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/icons/MGrep.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.progress.setWindowIcon(icon) # imposto valore minimo e massimo a 0 in modo venga considerata una progress a tempo indefinito # Attenzione! dentro nel ciclo deve essere usata la funzione setvalue altrimenti non visualizza e non avanza nulla! self.progress.setMinimum(0) self.progress.setMaximum(100) # creo un campo label che viene impostato con 100 caratteri in modo venga data una dimensione di base standard self.progress_label = QtWidgets.QLabel() self.progress_label.setText('.'*100) # collego la label già presente nell'oggetto progress bar con la mia label self.progress.setLabel(self.progress_label) #Compilazione su server 12g if self.compilazione('10.0.4.14', self.o_preferenze.v_server_password_iAS, p_sorgente, p_work_dir, p_tipo) == 'ok': message_info('Pubblication completed successful!') self.progress.close() self.close()
def __init__(self, p_work_dir, p_csv_separator, p_modalita_test): # rendo la mia classe una superclasse super(convert_csv_clipboard_to_excel, self).__init__() # controllo sia stato indicato il separatore csv if p_csv_separator == '': message_error('Insert a csv separator!') return None # nome file di lavoro v_nome_file_di_lavoro = p_work_dir + '\\clipboard.csv' # definizione del file di destinazione (apertura della finestra di dialogo e richiesta del file di arrivo) #v_xls_name = p_work_dir + '\\clipboard.xlsx' v_xls_name = QtWidgets.QFileDialog.getSaveFileName( self, "Save a Excel file", "export.xlsx", "XLSX (*.xlsx)")[0] if v_xls_name == "": message_error("Not a valid file name is selected") return None # creazione della wait window self.v_progress_step = 0 self.progress = QtWidgets.QProgressDialog(self) self.progress.setMinimumDuration(0) self.progress.setWindowModality(QtCore.Qt.WindowModal) self.progress.setWindowTitle("Copy...") # icona di riferimento icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/icons/MGrep.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.progress.setWindowIcon(icon) # imposto valore minimo e massimo a 0 in modo venga considerata una progress a tempo indefinito # Attenzione! dentro nel ciclo deve essere usata la funzione setvalue altrimenti non visualizza e non avanza nulla! self.progress.setMinimum(0) self.progress.setMaximum(100) # creo un campo label che viene impostato con 100 caratteri in modo venga data una dimensione di base standard self.progress_label = QtWidgets.QLabel() self.progress_label.setText('.' * 100) # collego la label già presente nell'oggetto progress bar con la mia label self.progress.setLabel(self.progress_label) ############################################### # lettura della clipboard e scrittura in file ############################################### import ctypes CF_TEXT = 1 kernel32 = ctypes.windll.kernel32 user32 = ctypes.windll.user32 user32.OpenClipboard(0) if user32.IsClipboardFormatAvailable(CF_TEXT): data = user32.GetClipboardData(CF_TEXT) data_locked = kernel32.GlobalLock(data) text = ctypes.c_char_p(data_locked) file = open(v_nome_file_di_lavoro, 'wb') file.write(text.value) file.close() kernel32.GlobalUnlock(data_locked) else: message_error("Clipboard not contains csv format text") return None user32.CloseClipboard() ######################################## #Apro il file e conto le righe v_total_rows = 0 with open(v_nome_file_di_lavoro, encoding='latin-1', mode='r') as v_file: for v_line in v_file: v_total_rows += 1 #Calcolo l'1% che rappresenta lo spostamento della progress bar v_rif_percent = 0 if v_total_rows > 100: v_rif_percent = v_total_rows // 100 #Creazione del file excel workbook = Workbook(v_xls_name) worksheet = workbook.add_worksheet() #Rileggo il file e converto da un formato all'altro v_progress = 0 v_y = 0 with open(v_nome_file_di_lavoro, encoding='latin-1', mode='r') as v_file: for v_line in v_file: v_valori = v_line.split(p_csv_separator) v_x = 0 for campo in v_valori: if check_campo_numerico(campo): worksheet.write(v_y, v_x, campo_numerico(campo)) else: worksheet.write(v_y, v_x, campo) v_x += 1 v_y += 1 #Emetto percentuale di avanzamento ma solo se righe maggiori di 100 if v_total_rows > 100: v_progress += 1 if v_progress % v_rif_percent == 0: self.avanza_progress( 'Total record to copy: ' + str(v_total_rows), False) #Chiusura del file e del db self.avanza_progress('Finalizing process...', True) self.avanza_progress('Finalizing process...', True) workbook.close() #Messaggio finale message_info('File ' + v_xls_name + ' created!') #Il file di lavoro viene eliminatao os.remove(os.path.join(v_nome_file_di_lavoro)) return None
def __init__(self, p_table_name, p_sqlite_db_name, p_excel_file, p_modalita_test): # rendo la mia classe una superclasse super(export_from_sqlite_to_excel, self).__init__() # creazione della wait window self.v_progress_step = 0 self.progress = QtWidgets.QProgressDialog(self) self.progress.setMinimumDuration(0) self.progress.setWindowModality(QtCore.Qt.WindowModal) self.progress.setWindowTitle("Copy...") # icona di riferimento icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/icons/MGrep.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.progress.setWindowIcon(icon) # imposto valore minimo e massimo a 0 in modo venga considerata una progress a tempo indefinito # Attenzione! dentro nel ciclo deve essere usata la funzione setvalue altrimenti non visualizza e non avanza nulla! self.progress.setMinimum(0) self.progress.setMaximum(100) # creo un campo label che viene impostato con 100 caratteri in modo venga data una dimensione di base standard self.progress_label = QtWidgets.QLabel() self.progress_label.setText('.' * 100) # collego la label già presente nell'oggetto progress bar con la mia label self.progress.setLabel(self.progress_label) # creo una scritta iniziale... self.avanza_progress('Record count...', False) self.avanza_progress('Record count...', False) ############################### #Avvio la copia della tabella ############################### #Apre il DB sqlite (lo apro in modalità classica....non dovrei avere problemi con utf-8) v_sqlite_conn = sqlite3.connect(database=p_sqlite_db_name) v_sqlite_cur = v_sqlite_conn.cursor() #Conta dei record della tabella (serve unicamente per visualizzare la progress bar) query = 'SELECT COUNT(*) FROM ' + p_table_name try: v_sqlite_cur.execute(query) except: message_error("Table in SQLite DB not exists!") #esco return None v_total_rows = 0 for row in v_sqlite_cur: v_total_rows = row[0] #Calcolo l' 1% che rappresenta lo spostamento della progress bar v_rif_percent = 0 if v_total_rows > 100: v_rif_percent = v_total_rows // 100 #Creazione del file excel workbook = Workbook(p_excel_file) worksheet = workbook.add_worksheet() #Estraggo elenco dei campi v_struttura = estrae_struttura_tabella_sqlite('1', v_sqlite_cur, p_table_name) #Carico elenco dei campi nella prima riga del foglio pos = 0 for i in v_struttura: worksheet.write(0, pos, i) pos += 1 #Carico tutte le altre righe della tabella v_progress = 0 query = 'SELECT * FROM ' + p_table_name v_sqlite_cur.execute(query) for i, row in enumerate(v_sqlite_cur): for j, value in enumerate(row): worksheet.write(i + 1, j, row[j]) #Emetto percentuale di avanzamento ma solo se righe maggiori di 100 if v_total_rows > 100: v_progress += 1 if v_progress % v_rif_percent == 0: self.avanza_progress( 'Total records to copy: ' + str(v_total_rows), False) #Chiusura del file e del db self.avanza_progress('Finalizing process...', True) self.avanza_progress('Finalizing process...', True) workbook.close() v_sqlite_conn.close() #Messaggio finale message_info('Table export completed!') return None
def copia_tabella(self, v_user_db, v_password_db, v_dsn_db, v_table_name, v_table_where, v_sqlite_db_name, v_blob_pathname): #Collegamento a Oracle try: v_oracle_db = cx_Oracle.connect(user=v_user_db, password=v_password_db, dsn=v_dsn_db) except: message_error("Connecting problems to Oracle DB!") #esco return 'ko' v_oracle_cursor = v_oracle_db.cursor() #Apre il DB sqlite v_sqlite_conn = sqlite3.connect(database=v_sqlite_db_name) #Indico al db di funzionare in modalità byte altrimenti ci sono problemi nel gestire utf-8 v_sqlite_conn.text_factory = bytes v_sqlite_cur = v_sqlite_conn.cursor() #Controllo se tabella SQLite esiste già v_sqlite_cur.execute("SELECT COUNT(*) FROM sqlite_master WHERE name='" + v_table_name + "'") #Se la tabella esiste chiedo se posso sovrascrivere if v_sqlite_cur.fetchone()[0] > 0: if message_question_yes_no("Table in SQLite DB already exist! Do you want overwrite it?") == 'Yes': #Cancello la tabella se già presente nel db sqlite query ='DROP TABLE ' + v_table_name v_sqlite_cur.execute(query) else: #esco return 'ko' #Conta dei record nella tabella sorgente Oracle #Aggiungo la where (solo se caricata) query = 'SELECT COUNT(*) FROM ' + v_table_name if len(v_table_where.split()) > 0: query += ' WHERE ' + v_table_where try: v_oracle_cursor.execute(query) except: message_error("Oracle table do not exists or errors in 'where' condition!") #esco return 'ko' v_total_rows = 0 for row in v_oracle_cursor: v_total_rows = row[0] #Calcolo 1% che rappresenta lo spostamento della progress bar v_rif_percent = 0 if v_total_rows > 100: v_rif_percent = v_total_rows // 100 #Creo la tabella in ambiente di backup (ottengo lo script di create table) query = estrae_struttura_tabella_oracle('c', v_oracle_cursor, v_user_db, v_table_name) v_sqlite_cur.execute(query) #Creo una lista con le posizioni dei campi dove si trovano i blob #In pratica un array dove sono segnati le posizioni dei campi #Esempio: #CREATE TABLE ta_files ( # files_nu NUMBER(8,0) NOT NULL, # modul_do VARCHAR2(1) NOT NULL, # files_do VARCHAR2(1) NOT NULL, # filen_co VARCHAR2(200) NOT NULL, # exten_co VARCHAR2(20) NULL, # files_fi BLOB NULL, # .... #) #La lista conterrà un solo elemento con valore 6 indicante la posizione del campo files_fi v_posizioni_blob = estrae_struttura_tabella_oracle('b', v_oracle_cursor, v_user_db, v_table_name) v_estensione_blob = estrae_struttura_tabella_oracle('e', v_oracle_cursor, v_user_db, v_table_name) #Se nella tabella sono presenti dei blob, creo una cartella nel file system dove ci finiranno i blob if v_posizioni_blob: message_info('Table contains blob data! It will be copied in ' + v_blob_pathname + v_table_name) try: os.mkdir(v_blob_pathname + v_table_name) except: message_error('The table contains blob fields! The copy must create the directory ' + v_table_name + ' but this already exists!') exit() #In questa cartella inserisco un file di testo che riporta le posizioni dei blob. Tale file verrà poi utilizzo nel caso #si voglia ricopiare la tabella dentro Oracle v_file_allegato = open(v_blob_pathname + v_table_name + '\\blob_fields_position.ini','w') v_file_allegato.write(str(v_posizioni_blob)) v_file_allegato.close() #Copia dei dati query = estrae_struttura_tabella_oracle('s', v_oracle_cursor, v_user_db, v_table_name) #if v_table_where is not None: if len(v_table_where.split()) > 0: query += ' WHERE ' + v_table_where v_insert_base = estrae_struttura_tabella_oracle('i', v_oracle_cursor, v_user_db, v_table_name) v_oracle_cursor.execute(query) v_progress = 0 v_puntatore_blob = 0 v_valore_colonna = str() for row in v_oracle_cursor: v_1a_volta = True v_insert = v_insert_base for count, column in enumerate(row): if column is None: v_valore_colonna = '' else: v_valore_colonna = column #se la colonna è un blob --> sostituisco il contenuto con quello del puntatore #e scrivo il contenuto della colonna come file separato in directory a parte if v_posizioni_blob: if count+1 in v_posizioni_blob: v_puntatore_blob += 1 v_file_allegato = open(v_blob_pathname + v_table_name + '\\' + str(v_puntatore_blob) + '.zzz','wb') v_file_allegato.write(column.read()) v_file_allegato.close() v_valore_colonna = str(v_puntatore_blob) #compongo la insert con il contenuto della colonna (da notare il replace del carattere " con apice singolo!) v_valore_colonna = str(v_valore_colonna) if v_1a_volta: v_insert += '"' + v_valore_colonna.replace('"',"'") + '"' else: v_insert += ',"' + v_valore_colonna.replace('"',"'") + '"' v_1a_volta = False v_insert += ')' v_sqlite_cur.execute(v_insert) #Emetto percentuale di avanzamento ma solo se righe maggiori di 100 if v_total_rows > 100: v_progress += 1 if v_progress % v_rif_percent == 0: self.avanza_progress('Total records to copy: ' + str(v_total_rows)) #print('Avanzamento scrittura...' + str((v_progress*100//v_total_rows)+1) + '%') #commit v_sqlite_conn.commit() #chiusura dei cursori v_sqlite_conn.close() v_oracle_cursor.close() return 'ok'
def __init__(self, p_debug, p_user_db, p_password_db, p_dsn_db, p_table_name, p_excel_file, p_modalita_test): # rendo la mia classe una superclasse super(import_excel_into_oracle, self).__init__() # creazione della wait window self.v_progress_step = 0 self.progress = QtWidgets.QProgressDialog(self) self.progress.setMinimumDuration(0) self.progress.setWindowModality(QtCore.Qt.WindowModal) self.progress.setWindowTitle("Copy...") # icona di riferimento icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/icons/MGrep.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.progress.setWindowIcon(icon) # imposto valore minimo e massimo a 0 in modo venga considerata una progress a tempo indefinito # Attenzione! dentro nel ciclo deve essere usata la funzione setvalue altrimenti non visualizza e non avanza nulla! self.progress.setMinimum(0) self.progress.setMaximum(100) # creo un campo label che viene impostato con 100 caratteri in modo venga data una dimensione di base standard self.progress_label = QtWidgets.QLabel() self.progress_label.setText('.' * 100) # collego la label già presente nell'oggetto progress bar con la mia label self.progress.setLabel(self.progress_label) # creo una scritta iniziale... self.avanza_progress("Analizing excel file...") self.avanza_progress("Analizing excel file...") #Apro il file di excel try: wb = open_workbook(filename=p_excel_file) except: message_error('Format file invalid. Only xlsx file format!') #esco return None #Se il file contiene più fogli, avverto che verrà preso solo il primo if len(wb.sheets()) > 1: message_info( 'This file contains more than one sheet. It will be taken the first ' + wb.sheet_by_index(0).name + '!') #Mi posiziono sul primo foglio v_foglio = wb.sheet_by_index(0) #Estraggo la struttura del foglio self.v_numero_totale_righe = 0 self.v_debug = p_debug v_definizione_colonne = self.struttura_foglio(v_foglio) self.avanza_progress('Total records number to copy...' + str(self.v_numero_totale_righe)) #Collegamento a Oracle try: self.v_oracle_db = cx_Oracle.connect(user=p_user_db, password=p_password_db, dsn=p_dsn_db, encoding="UTF-8", nencoding="UTF-8") except: message_error('Connecting problems to Oracle DB!') #esco return None self.v_oracle_cursor = self.v_oracle_db.cursor() #Creo la tabella if self.creo_tabella(v_definizione_colonne, p_table_name) == 'ok': if self.importa_foglio(v_foglio, v_definizione_colonne, p_table_name) == 'ok': #Messaggio finale message_info('Action completed with ' + str(self.v_numero_totale_righe) + ' records imported!') self.v_oracle_db.close() return None
def __init__(self, p_csv_name, p_csv_separator, p_modalita_test): # rendo la mia classe una superclasse super(convert_csv_to_excel, self).__init__() # creazione della wait window self.v_progress_step = 0 self.progress = QtWidgets.QProgressDialog(self) self.progress.setMinimumDuration(0) self.progress.setWindowModality(QtCore.Qt.WindowModal) self.progress.setWindowTitle("Copy...") # icona di riferimento icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/icons/icons/MGrep.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.progress.setWindowIcon(icon) # imposto valore minimo e massimo a 0 in modo venga considerata una progress a tempo indefinito # Attenzione! dentro nel ciclo deve essere usata la funzione setvalue altrimenti non visualizza e non avanza nulla! self.progress.setMinimum(0) self.progress.setMaximum(100) # creo un campo label che viene impostato con 100 caratteri in modo venga data una dimensione di base standard self.progress_label = QtWidgets.QLabel() self.progress_label.setText('.' * 100) # collego la label già presente nell'oggetto progress bar con la mia label self.progress.setLabel(self.progress_label) # controllo sia stato indicato il separatore csv if p_csv_separator == '': message_error('Insert a csv separator!') return None #Spezzo il nome del file per ricavare il nome di destinazione e controllo che la destinazione non esista v_solo_nome_file = os.path.split(p_csv_name)[1] v_solo_directory = os.path.split(p_csv_name)[0] v_solo_nome_file_senza_suffisso = os.path.splitext(v_solo_nome_file)[0] v_suffisso_nome_file = os.path.splitext(v_solo_nome_file)[1] v_xls_name = v_solo_directory + '//' + v_solo_nome_file_senza_suffisso + '.xlsx' if os.path.isfile(v_xls_name): if message_question_yes_no( "Destination file already exists. Do you to replace it?" ) == 'No': # esco dalla procedura perché utente ha deciso di non preseguire return None #Apro il file e conto le righe v_total_rows = 0 with open(p_csv_name, encoding='latin-1', mode='r') as v_file: for v_line in v_file: v_total_rows += 1 #Calcolo l'1% che rappresenta lo spostamento della progress bar v_rif_percent = 0 if v_total_rows > 100: v_rif_percent = v_total_rows // 100 #Creazione del file excel workbook = Workbook(v_xls_name) worksheet = workbook.add_worksheet() #Rileggo il file e converto da un formato all'altro v_progress = 0 v_y = 0 with open(p_csv_name, encoding='latin-1', mode='r') as v_file: for v_line in v_file: v_valori = v_line.split(p_csv_separator) v_x = 0 for campo in v_valori: if check_campo_numerico(campo): worksheet.write(v_y, v_x, campo_numerico(campo)) else: worksheet.write(v_y, v_x, campo) v_x += 1 v_y += 1 #Emetto percentuale di avanzamento ma solo se righe maggiori di 100 if v_total_rows > 100: v_progress += 1 if v_progress % v_rif_percent == 0: self.avanza_progress('Total record to copy: ' + str(v_total_rows)) #Chiusura del file e del db self.avanza_progress('Finalizing process...') workbook.close() #Messaggio finale message_info('File conversion completed!') return None