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
