def spazio_disco(self, p_ip_server, p_pwd):
"""
Funzione che esegue il comando "df -h" sul server indicato e lo restituisce come stringa di output
Attenzione! Utente di collegamento è oracle
"""
#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 = ''
try:
#spazio del disco. Il comando vero e proprio è "df -h"
v_command = 'echo y | utility_prog\\plink -pw ' + p_pwd + ' oracle@' + p_ip_server + ' df -h '
v_ssh = subprocess.Popen(v_command,
shell=True,
stdin=subprocess.PIPE,
stdout=v_sshoutput,
stderr=v_sshoutputerror)
v_ssh.communicate(v_sshinput)
except:
message_error('Plink command error on ' + p_ip_server + '!')
return 'ko'
# leggo il risultato e lo visualizzo
return open(self.o_preferenze.work_dir + '\\sshoutput.txt', 'r').read()
def folder_ora02(self, p_ip_server, p_pwd):
"""
Funzione che esegue il comando "ls" sul server indicato e lo restituisce come stringa di output
Attenzione! Utente di collegamento è oracle
"""
#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 = ''
try:
#comando list con opzione verticale (-l) e unità di misura megabyte (-h)
v_command = 'echo y | utility_prog\\plink -pw ' + p_pwd + ' oracle@' + p_ip_server + ' ls -lh /ora02/arch/'
v_ssh = subprocess.Popen(v_command,
shell=True,
stdin=subprocess.PIPE,
stdout=v_sshoutput,
stderr=v_sshoutputerror)
v_ssh.communicate(v_sshinput)
except:
message_error('Plink command error on ' + p_ip_server + '!')
return 'ko'
# leggo il risultato e lo visualizzo
return open(self.o_preferenze.work_dir + '\\sshoutput.txt', 'r').read()
def starter(self):
"""
Caricamento della pagina iniziale
"""
# connessione al DB come amministratore
try:
self.oracle_con = 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
# cambio la label del pulsante di calcoloo in modo sia riportata l'ora di riferimento
self.b_calculate.setText(
"Compute difference from " +
str(datetime.datetime.now().strftime('%H:%M:%S')))
# cancello il contenuto delle pagine di ut_report (tranne record posizione 0)
self.t_report.delete_page(self.fname, self.page1)
# carico in pagina1 di ut_report, il punto di partenza della situazione sessioni
self.load_from_oracle_top_sessions(self.page1)
# visualizzo il contenuto della pagina3
self.load_screen(self.page1)
def top(self, p_ip_server, p_pwd):
"""
Funzione che esegue il comando "top" sul server indicato e lo restituisce come stringa di output
Nello specifico l'opzione -b indica di mandare l'output sul file e -n il numero di iterazioni da svolgere
Attenzione! Utente di collegamento è oracle
"""
#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 = ''
try:
#comando top con opzione -b (esecuzione in batch) e iterazioni 1
v_command = 'echo y | utility_prog\\plink -pw ' + p_pwd + ' oracle@' + p_ip_server + ' top -b -n 1 '
v_ssh = subprocess.Popen(v_command,
shell=True,
stdin=subprocess.PIPE,
stdout=v_sshoutput,
stderr=v_sshoutputerror)
v_ssh.communicate(v_sshinput)
except:
message_error('Plink command error on ' + p_ip_server + '!')
return 'ko'
# leggo il risultato e lo visualizzo
return open(self.o_preferenze.work_dir + '\\sshoutput.txt', 'r').read()
def o_lst1_slot(self, p_index):
"""
doppio click su listbox di ricerca stringa apre il file indicato
"""
v_selindex = self.lista_risultati.itemFromIndex(p_index)
v_seltext = v_selindex.text()
# apro il source scelto a video in base alla tipologia di appartenenza
if v_seltext[0:11] == 'PACKAGE -->':
self.apre_source_db(
'PACKAGE', v_seltext[v_seltext.find('>') + 2:len(v_seltext)])
elif v_seltext[0:11] == 'TRIGGER -->':
self.apre_source_db(
'TRIGGER', v_seltext[v_seltext.find('>') + 2:len(v_seltext)])
elif v_seltext[0:13] == 'PROCEDURE -->':
self.apre_source_db(
'PROCEDURE', v_seltext[v_seltext.find('>') + 2:len(v_seltext)])
elif v_seltext[0:12] == 'FUNCTION -->':
self.apre_source_db(
'FUNCTION', v_seltext[v_seltext.find('>') + 2:len(v_seltext)])
elif v_seltext[0:9] == 'TABLE -->':
self.apre_source_db(
'TABLE', v_seltext[v_seltext.find('>') + 2:len(v_seltext)])
elif v_seltext[0:8] == 'VIEW -->':
self.apre_source_db(
'VIEW', v_seltext[v_seltext.find('>') + 2:len(v_seltext)])
# documento windows (es. form o report, doc, xls, ecc.)
elif v_seltext != '':
try:
os.startfile(v_seltext)
except:
message_error(
'File not found or problem during open application!')
def carica_oggetti_invalidi_db(self):
"""
carica elenco degli oggetti invalidi
"""
# connessione al DB come amministratore
try:
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 cursori
v_cursor = v_connection.cursor()
# select per la ricerca degli oggetti invalidi
v_cursor.execute(
"SELECT OWNER, OBJECT_NAME, OBJECT_TYPE FROM ALL_OBJECTS WHERE STATUS='INVALID' AND OWNER NOT IN ('SYS','APEX_040200') AND OBJECT_NAME NOT LIKE 'OLAP_OLEDB%' ORDER BY OBJECT_TYPE"
)
# carico tutte le righe in una lista
v_row = v_cursor.fetchall()
v_cursor.close()
v_connection.close()
# restituisco la matrice
return v_row
def pubblica(self, p_tipo_server):
"""
Pubblica il file Oracle Form o Oracle Report nei server indicati
se p_tipo_server = 1 compila in SMILE, altrimenti in ICOM
"""
from compile_oracle_form_report import pubblica_form_report
# 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_file = v_item.text()
# tipo server
if p_tipo_server == '1':
v_nome = 'SMILE'
else:
v_nome = 'ICOM'
# se è stato selezionato qualcosa
if v_file != '' and message_question_yes_no(
"Do you want to compile the file " + chr(10) + v_file +
chr(10) + "and post it in " + v_nome + " system?") == 'Yes':
#sono ammessi solo file con suffissi specifici
if '.fmb' not in v_file and '.rdf' not in v_file:
message_error(
'File is not in format "Oracle Form" or "Oracle Report"!')
else:
# apro una nuova finestra figlia della principale
pubblica_form_report(v_file, self.o_preferenze.work_dir,
p_tipo_server)
def b_search_slot(self):
"""
esegue la ricerca
"""
if self.e_url.displayText() == '':
message_error('Please insert a valid URL')
return None
# pulizia dell'item dei risultati
self.lista_risultati.clear()
# legge la pagina web
try:
v_pagina_web = request.urlopen(self.e_url.displayText())
except:
message_error('Page not found or unknow error')
return None
v_contenuto = str(v_pagina_web.read())
v_pos = v_contenuto.find('<img alt="')
v_risultato = []
while v_pos > 0:
v_pos_fin = v_contenuto.find('"', v_pos + 10)
v_risultato.append(v_contenuto[v_pos + 10:v_pos_fin])
v_pos = v_contenuto.find('<img alt="', v_pos + 1)
# carica la lista ordinando i risultati alfabeticamente
v_risultato_ordinato = sorted(v_risultato)
for i in range(1, len(v_risultato_ordinato)):
self.lista_risultati.appendRow(
QtGui.QStandardItem(v_risultato_ordinato[i]))
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 get_totale_sessioni_per_utente(self):
"""
Restituisce totale delle sessioni aperte raggruppate per username
"""
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 cursori
v_cursor = v_connection.cursor()
v_user = ""
# ricerca parziale su nome utente
if self.e_user_name.displayText() != '':
v_user += " AND Upper(USERNAME) LIKE '%" + self.e_user_name.displayText(
).upper() + "%' "
# ricerca parziale su nome programma
if self.e_program_name.displayText() != '':
v_user += " AND Upper(MODULE) LIKE '%" + self.e_program_name.displayText(
).upper() + "%' "
# ricerca parziale su nome terminale
if self.e_terminal.displayText() != '':
v_user += " AND Upper(TERMINAL) LIKE '%" + self.e_terminal.displayText(
).upper() + "%' "
# select per il conteggio delle sessioni aperte per utente. Se il modulo è ICOM viene preso il campo terminale
v_select = "SELECT COUNT(*) \n\
FROM (SELECT DECODE(MODULE,'UNIFACE.EXE',TERMINAL,USERNAME) \n\
FROM V$SESSION,(SELECT PROG_CO, PROG_DE FROM ML_PROG WHERE LNG_CO = 'I') ML_PROG \n\
WHERE USERNAME NOT IN ('SYS','SYSTEM','DBSNMP') AND MODULE = PROG_CO(+) \n\
" + v_user + "GROUP BY DECODE(MODULE,'UNIFACE.EXE',TERMINAL,USERNAME) \n\
)"
v_cursor.execute(v_select)
# integro i risultati della prima select con altri dati e li carico in una tupla
v_totale = 0
for result in v_cursor:
# carico la riga nella tupla (notare le doppie parentesi iniziali che servono per inserire nella tupla una lista :-))
v_totale = result[0]
# chiudo sessione
v_cursor.close()
v_connection.close()
# restituisco totale
return v_totale
def slot_create_script(self):
"""
Crea lo script SQL per lanciare la creazione di un nuovo DBFile
"""
# ottengo un oggetto index-qt della riga selezionata
index = self.o_lst1.currentIndex()
# non devo prendere la cella selezionata ma le celle 0 e 1 della riga selezionata (quella che contiene il nome dello schema e della tabella)
v_item_0 = self.lista_risultati.itemFromIndex(
index.sibling(index.row(), 0))
v_item_1 = self.lista_risultati.itemFromIndex(
index.sibling(index.row(), 1))
if v_item_0 != None:
v_schema = v_item_0.text()
v_tabella = v_item_1.text()
v_script = 'ALTER TABLE ' + v_schema + '.' + v_tabella + ' MOVE'
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 cursori
v_cursor = v_connection.cursor()
# select table space
v_select = """SELECT INDEX_NAME, TABLESPACE_NAME
FROM DBA_INDEXES
WHERE OWNER = '""" + v_schema + """'
AND TABLE_NAME= '""" + v_tabella + """'
AND INDEX_TYPE='NORMAL'
ORDER BY INDEX_NAME
"""
# carico i dati
v_cursor.execute(v_select)
v_rows = v_cursor.fetchall()
# chiudo sessione
v_cursor.close()
v_connection.close()
# compongo il resto dello script con il nome degli indici
for v_row in v_rows:
v_script = v_script + chr(10) + '/' + chr(
10
) + 'ALTER INDEX ' + v_schema + '.' + v_row[0] + ' REBUILD'
self.e_sql_script.setText(v_script)
def compila(self, p_nome_programma, p_server):
"""
Compila il p_nome_programma
"""
if p_nome_programma != '':
try:
os.system('c:\ITCCONF\compilaauto.bat "' + p_nome_programma +
'" ' + p_server)
except:
message_error('Problem during object compile!')
def b_search_slot(self):
"""
esegue la ricerca del file
"""
# creazione della wait window
self.progress = QtWidgets.QProgressDialog(self)
self.progress.setMinimumDuration(0)
self.progress.setWindowModality(QtCore.Qt.WindowModal)
self.progress.setWindowTitle("Please wait...")
# 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(0)
# 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)
v_ok = True
# controllo che ci siano i dati obbligatori
if self.e_filesearch.displayText() == '':
message_error('Please enter a file name')
v_ok = False
if self.e_pathname.displayText() == '':
message_error('Please enter a pathname')
v_ok = False
# i controlli sono stati superati --> avvio la ricerca
if v_ok:
# Se la cache non è attiva, controllo se sono cambiati i valori di ricerca (es. path) perché allora vuol dire che la cache va ripristinata
if not self.c_cache_file_system.isChecked():
if self.v_t2_pathname != self.e_pathname.displayText(
) or self.v_t2_filter != self.e_filter.displayText(
) or self.v_t2_excludepath != self.e_excludepath.displayText():
# I valori sono cambiati e la cache va ricaricata
self.c_cache_file_system.setChecked()
# Carico le var globali che permetteranno il confronto ai giri successivi. In pratica la cache va ricaricata automaticamente se sono cambiati dei parametri di ricerca
self.v_t2_pathname = self.e_pathname.displayText()
self.v_t2_filter = self.e_filter.displayText()
self.v_t2_excludepath = self.e_excludepath.displayText()
# pulizia dell'item dei risultati
self.lista_risultati.clear()
# richiama la ricerca nel file system se presente file system
self.ricerca_file(self.e_pathname.displayText(),
self.e_filesearch.displayText(),
self.e_filter.displayText(),
self.e_excludepath.displayText())
# chiudo la wait window
self.progress.close()
def creo_tabella(self, p_definizione_colonne, p_table_name):
#se siamo in modalità test --> cancello la tabella
if self.v_debug:
try:
print("Cancellazione della tabella " + p_table_name)
v_query = 'DROP TABLE ' + p_table_name
self.v_oracle_cursor.execute(v_query)
except:
pass
v_query = 'CREATE TABLE ' + p_table_name + '('
v_1a_volta = True
#definizione_colonne risulta così strutturata
#1° campo = Nome
#2° campo = Tipo (varchar2, number)
#3° campo = Larghezza colonna (per numeri solo la parte intera)
#4° campo = Larghezza decimali (solo per numeri con decimali)
for valori in p_definizione_colonne:
if v_1a_volta:
v_1a_volta = False
else:
v_query += ','
v_query += valori[0] + ' ' + valori[1]
if valori[1] == 'VARCHAR2':
#la colonna risulta varchar2 ma sono stati trovati all'interno dei numeri con decimali....per evitare
#problemi aumento la grandezza della colonna aggiungendo anche i decimali + altri due caratteri per
#separatore decimali e eventuale segno meno
if valori[3] > 0:
v_query += '(' + str(valori[2] + valori[3] + 2) + ')'
#altrimenti è puro char
else:
v_query += '(' + str(valori[2]) + ')'
elif valori[1] == 'NUMBER':
v_query += '(' + str(valori[2] + valori[3]) + ',' + str(
valori[3]) + ')'
v_query += ')'
if self.v_debug:
print("Creazione della tabella " + v_query)
#Invio del comando di creazione tabella
try:
self.v_oracle_cursor.execute(v_query)
except:
message_error(
"Problem during create Oracle table!" + chr(10) +
"The table " + p_table_name + " already exists?" + chr(10) +
"Remember that the excel file must be haven't formatting and filters activated!"
)
#esco
return 'ko'
return 'ok'
def slot_doppio_click_lista(self, p_index):
"""
Doppio click su listbox
"""
v_selindex = self.lista_risultati.itemFromIndex(p_index)
v_seltext = v_selindex.text()
if v_seltext != '':
try:
os.startfile(v_seltext)
except:
message_error(
'File not found or problem during open application!')
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_load(self):
"""
Carica un file sql
"""
fileName = QtWidgets.QFileDialog.getOpenFileName(
self, "Choose a sql file", "", "Sql (*.sql)")
if fileName[0] != "":
try:
v_file = open(fileName[0], 'r')
self.e_sql.clear()
self.e_sql.setText(v_file.read())
except:
message_error('Error to opened the file')
def o_lst1_slot(self, p_index):
"""
doppio click su listbox di ricerca stringa apre il file indicato
"""
v_selindex = self.lista_risultati.itemFromIndex(p_index)
v_seltext = v_selindex.text()
if v_seltext != '':
try:
os.startfile(v_seltext)
except:
message_error(
'File not found or problem during open application!')
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 fileSaveAs(self):
fn, _ = QtWidgets.QFileDialog.getSaveFileName(oracle_my_sql_window, "Save as...", self.filename,"SQL files (*.sql)")
if not fn:
message_error('Error saving')
return False
lfn = fn.lower()
if not lfn.endswith('.sql'):
fn += '.sql'
self.filename = fn
self.fname = os.path.splitext(str(fn))[0].split("/")[-1]
return self.fileSave()
def ricerca_stringa_in_icom(self, v_string1, v_string2, v_output):
"""
ricerca stringa in sorgenti ICOM-UNIFACE
"""
v_abort = False
try:
v_connection = cx_Oracle.connect(
'icom_ng_source/icom_ng_source@uniface')
v_error = False
except:
message_error(
'Connection rejected! Search in ICOM-UNIFACE will skipped!')
v_error = True
v_progress_step = 0
if not v_error:
# apro il file di output che conterra' i risultati della ricerca
f_output = open(v_output, 'a')
# apro cursori
v_cursor = v_connection.cursor()
v_cursor_det = v_connection.cursor()
# output a video del file in elaborazione (notare incremento del value e impostazione della label)
v_progress_step += 1
self.progress.setValue(v_progress_step)
self.progress_label.setText('ICOM-UNIFACE')
self.progress.setLabel(self.progress_label)
# eseguo la ricerca con apposita funzione
v_cursor.execute(
'SELECT rep_search_function(:string1,:string2) FROM dual', {
'string1': v_string1,
'string2': v_string2
})
for result in v_cursor:
if result[0] is not None:
v_lista = result[0].split(',')
for i in v_lista:
# output a video delle ricorrenze trovate
self.lista_risultati.appendRow(
QtGui.QStandardItem('ICOM source --> ' + i))
f_output.write('ICOM source' + ';' + i + ';\n')
# chiusura cursori e connessione DB
v_cursor.close()
v_connection.close()
f_output.close()
return v_abort
def get_elenco_tabelle_bloccate(self):
"""
Restituisce in una tupla elenco delle sessioni bloccate
"""
if self.e_table_name.currentText() == '':
message_error('Please insert a Oracle table name')
return []
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 []
v_row = []
# apro cursori
v_cursor = v_connection.cursor()
# select per la ricerca degli oggetti invalidi
v_select = """SELECT v$lock.SID SID,
v$session.SERIAL# SERIAL_NUMBER,
V$SESSION.USERNAME USERNAME,
V$SESSION.STATUS STATUS,
V$SESSION.OSUSER OSUSER,
V$SESSION.MACHINE MACHINE,
V$SESSION.PROGRAM||'.'||V$SESSION.MODULE PROGRAM
FROM v$lock, v$session
WHERE id1 = (SELECT object_id
FROM all_objects
WHERE owner ='SMILE' AND
object_name = RTRIM(LTRIM(UPPER('""" + self.e_table_name.currentText(
) + """')))) AND
v$lock.sid=v$session.sid"""
v_cursor.execute(v_select)
# carico tutte le righe in una lista
v_row = v_cursor.fetchall()
# chiudo connessione e restituisco la tupla
v_cursor.close()
v_connection.close()
return v_row
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 get_elenco_tabelle(self, p_table_to_search):
"""
Restituisce elenco dbfile in una table in base al tablespace ricevuto in ingresso
"""
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 cursori
v_cursor = v_connection.cursor()
# select table space
if p_table_to_search != '':
v_where = " AND TABLE_NAME LIKE '%' || '" + p_table_to_search.upper(
) + "' || '%'"
else:
v_where = ''
v_select = """SELECT OWNER,
TABLE_NAME,
ROUND((BLOCKS * 8)/1000,0) "SIZE_MBYTE",
ROUND((NUM_ROWS * AVG_ROW_LEN / 1024)/1000, 0) "ACTUAL_DATA_MBYTE",
(ROUND((BLOCKS * 8)/1000,0) - ROUND((NUM_ROWS * AVG_ROW_LEN / 1024)/1000, 0)) "WASTED_MBYTE"
FROM DBA_TABLES
WHERE (ROUND((BLOCKS * 8)/1000,0) - ROUND((NUM_ROWS * AVG_ROW_LEN / 1024)/1000, 0)) > 0
AND OWNER <> 'SYS'
""" + v_where + """
ORDER BY 5 DESC
"""
# carico i dati
v_cursor.execute(v_select)
v_row = v_cursor.fetchall()
# chiudo sessione
v_cursor.close()
v_connection.close()
# restituisco tupla delle righe
return v_row
def get_elenco_table_space(self):
"""
Restituisce in una tupla elenco dei table space
"""
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 cursori
v_cursor = v_connection.cursor()
# select table space
v_select = """SELECT DF.TABLESPACE_NAME "TABLESPACE",
ROUND(TU.TOTALUSEDSPACE * 100 / DF.TOTALSPACE) "PERC_USED",
DF.TOTALSPACE "TOTAL MB",
TOTALUSEDSPACE "USED MB",
(DF.TOTALSPACE - TU.TOTALUSEDSPACE) "FREE MB"
FROM (SELECT TABLESPACE_NAME,
ROUND(SUM(BYTES) / 1048576) TOTALSPACE
FROM DBA_DATA_FILES
GROUP BY TABLESPACE_NAME) DF,
(SELECT ROUND(SUM(BYTES)/(1024*1024)) TOTALUSEDSPACE,
TABLESPACE_NAME
FROM DBA_SEGMENTS
GROUP BY TABLESPACE_NAME) TU
WHERE DF.TABLESPACE_NAME = TU.TABLESPACE_NAME
AND DF.TOTALSPACE <> 0
ORDER BY ROUND(TU.TOTALUSEDSPACE * 100 / DF.TOTALSPACE) DESC
"""
# carico i dati
v_cursor.execute(v_select)
v_row = v_cursor.fetchall()
# chiudo sessione
v_cursor.close()
v_connection.close()
# restituisco tupla delle righe
return v_row
def slot_connect(self):
"""
Esegue connessione a Oracle
"""
try:
# chiudo eventuale connessione già aperta
if self.v_connesso:
self.v_cursor.close()
# connessione al DB come smile
self.v_connection = cx_Oracle.connect(user='******', password='******', dsn=self.e_server_name.currentText())
# apro cursore
self.v_cursor = self.v_connection.cursor()
# imposto var che indica la connesione a oracle
self.v_connesso = True
except:
message_error('Error to oracle connection!')
def slot_open_folder(self):
"""
Apre la cartella dove si trova il file selezionato
"""
try:
# ricerco la posizione dell'indice selezionato e ne ricavo il contenuto
v_index = self.o_lst1.selectedIndexes()[0]
v_item = self.lista_risultati.itemFromIndex(v_index)
v_seltext = v_item.text()
if v_seltext != '':
try:
os.startfile(v_seltext[0:v_seltext.rfind('\\')])
except:
message_error('Problem during open object folder!')
except:
message_error('Problem during open object folder!')
def slot_converte(self):
'''
Esegue la conversione del testo semplice in testo graphics ascii
'''
if self.e_converte.displayText() == '':
message_error('Please insert a text')
return None
# il risultato viene impostato con il font richiesto (da non confondersi con il font con cui viene visualizzato)
if self.e_fonts_list.currentText() != '':
risultato = pyfiglet.figlet_format( self.e_converte.displayText(), font=self.e_fonts_list.currentText() )
# se però non è stato indicato alcun fonts, lascio il default
else:
risultato = pyfiglet.figlet_format( self.e_converte.displayText() )
# imposto il risultato nella textbox
self.e_risultato.clear()
self.e_risultato.append(risultato)
def fileSave(self):
if (self.filename != ""):
file = QtCore.QFile(self.filename[0])
if not file.open( QtCore.QFile.WriteOnly | QtCore.QFile.Text):
message_error("Cannot write file %s:\n%s." % (self.filename, file.errorString()))
return
outstr = QtCore.QTextStream(file)
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
outstr << self.e_sql.toPlainText()
QtWidgets.QApplication.restoreOverrideCursor()
self.setModified(False)
self.fname = QtCore.QFileInfo(self.filename[0]).fileName()
oracle_my_sql_window.setWindowTitle(self.fname + "[*]")
else:
self.fileSaveAs()
def openFile(self):
"""
Apertura di un file
"""
if self.maybeSave():
fileName = QtWidgets.QFileDialog.getOpenFileName(oracle_my_sql_window, "Open File", QtCore.QDir.homePath() + "/Documents/","SQL Files (*.sql);;All Files (*.*)")
if fileName[0] != "":
try:
v_file = open(fileName[0],'r')
self.e_sql.clear()
self.e_sql.setPlainText( v_file.read() )
self.filename = fileName
self.setModified(False)
oracle_my_sql_window.setWindowTitle(self.titolo_window + ': ' + fileName[0])
self.document = self.e_sql.document()
except:
message_error('Error to opened the file')
