def add_link_col(self):
self.registerField('tree_widget_box_link_columns', self.treeWidget_linked_columns)
if self.df_compare:
target_column = [i for i in self.df_compare.parse(self.comboBox_set_list_checked.currentIndex()).columns.values]
else:
show_alarm_window(self, "Choose a link file !!!")
return
try:
source_column = [i for i in self.df.parse(self.comboBox_list_source_excel.currentIndex()).columns.values]
except:
show_alarm_window(self, "Choose a source file !!!")
return
row_check = LinkedColumns(
tree_widget=self.treeWidget_linked_columns,
parent=self.treeWidget_linked_columns,
target_columns=target_column,
source_columns=source_column,
current_column=None,
adapter=self.adapter)
self.treeWidget_linked_columns.addTopLevelItem(row_check)
self.pref['col_to_check'].append(row_check)
def add_table_dict(self):
for table in self.list_of_dict_pref:
if table['dictTableName'].combo_box_dictTableName.currentText() == '---':
show_alarm_window(self, "Select table name !!!")
return
if not isinstance(self.validator, type):
create_dict_column(pref=self.list_of_dict_pref,
parent=self,
cur_dic_table_pref=self.dict_pref,
config=self.config,
validator=self.validator,
tables_in_receiver=self.tables_in_receiver,
columns_names_source=self.columns_names_source,
adapter=self.adapter
)
else:
create_dict_column(pref=self.list_of_dict_pref,
parent=self,
cur_dic_table_pref=self.dict_pref,
config=self.config,
validator=self.validator,
tables_in_receiver=self.tables_in_receiver,
columns_names_source=self.columns_names_source,
dbtype=self.dbtype,
target_table=self.target_table,
db_base=self.db_base,
connector=self.connector,
executor=self.executor,
cur=self.cur,
loggerInst=self.loggerInst,
adapter=self.adapter
)
def show_pref(self):
if self.pref_gui:
self.pref_gui.show()
else:
if self.connector is None:
show_alarm_window(self, "Open config !!!")
self.close_project_data()
return
else:
try:
self.pref_gui = gui_prefernces_controller.Pref_Window(
main_gui_widget=self,
config_dict=self.config_dict,
pref=self.pref,
dbService=self.dbService,
logger_inst=self.loggerInst,
tables_in_db=self.tables_in_receiver,
schemas_in_db=self.schemas_in_db,
parent=self.pref_gui,
adapter=self.adapter)
self.pref_gui.show()
except Exception:
show_alarm_window(self, "Open config !!!")
self.close_project_data()
return
def write_xml(self, tree, root):
try:
tree.write(f"{self.path_name_config[0]}")
except Exception as e:
show_alarm_window(self, "Error at creating config !!!")
else:
self.ui.statusbar.showMessage(
f'Created XML: {self.path_name_config[0]}')
def write_edit_xml(self):
try:
self.tab_widget_editor.tree.write(
f"{self.tab_widget_editor.path_name_config}")
except Exception as e:
show_alarm_window(self, "Error at creating config !!!")
else:
self.ui.statusbar.showMessage(
f'Created XML: {self.tab_widget_editor.path_name_config}')
def validatePage(self) -> bool:
try:
self.wizard().page(0).pref['dbSchema'] = self.comboBox_dbSchema.currentText()
self.wizard().page(0).pref['target_table_name'] = self.target_table_name.currentText()
except Exception as e:
show_alarm_window(self, "Can't save params")
return False
else:
return True
def pre_on_start(self):
if self.comboBox.currentText() == '---':
show_alarm_window(self, 'Select configuration file !!!')
return
elif not hasattr(self, 'mode'):
show_alarm_window(self, 'Select loading mode !!!')
return
else:
self.on_start(config_path=self.config_path, mode=self.mode)
def deleteColumn(self):
if len(self.list_of_source_cols_links) > 1:
element = list(filter(lambda x: x['colName'].unique_name ==
self.treeWidget_of_Source.currentItem().unique_name,
self.list_of_source_cols_links))[0]
self.list_of_source_cols_links.remove(element)
self.treeWidget_of_Source.takeTopLevelItem(self.treeWidget_of_Source.indexFromItem(self.treeWidget_of_Source.currentItem()).row())
else:
show_alarm_window(self, "You can't delete last element !!!")
return
def delete_table_dict(self):
if len(self.list_of_dict_pref) > 1:
cur_column = list(
filter(lambda x: x['dictTableName'].unique_name == self.currentItem().unique_name,
self.list_of_dict_pref)
)[0]
else:
show_alarm_window(self,"You can't delete last element !!!")
return
self.list_of_dict_pref.remove(cur_column)
self.takeTopLevelItem(self.indexFromItem(self.currentItem()).row())
def deleteReplace(self):
cur_column = list(filter(lambda x: x['colName'].combo_box_name.currentText() ==
self.treeWidget_of_Source.currentItem().parent().combo_box_name.currentText(),
self.list_of_source_cols_links))[0]
if len(cur_column['replace_box']) > 1:
cur_column['replace_box'].remove(self.treeWidget_of_Source.currentItem())
else:
show_alarm_window(self, "You can't delete last element !!!")
return
self.treeWidget_of_Source.currentItem().parent().takeChild(
self.treeWidget_of_Source.indexFromItem(self.treeWidget_of_Source.currentItem()).row())
def addColumnField(self):
for column in self.list_of_source_cols_links:
if column['colName'].combo_box_name.currentText() == '---':
show_alarm_window(self, "Select column name !!!")
return
source_column_editor_viewer.create_input_column(
tree_table=self.treeWidget_of_Source,
db_colnames=self.colnames_of_receiver,
column_property=self.dict_pref,
list_of_cols=self.list_of_source_cols_links,
indx=self.treeWidget_of_Source.indexFromItem(
self.treeWidget_of_Source.currentItem()).row(),
source_columnes=self.columns_in_source,
adapter=self.adapter)
def write_as_xml(self, tree, root, path=None):
try:
if path:
tree.write(f"{path}")
else:
tree.write(f"{self.path_to_save[0]}")
except Exception as e:
show_alarm_window(self, "Error at creating config !!!")
else:
if path:
self.ui.statusbar.showMessage(f'Created XML: {path}')
else:
self.ui.statusbar.showMessage(
f'Created XML: {self.path_to_save[0]}')
def delete_column(self):
cur_table = list(
filter(lambda x: x['dictTableName'].combo_box_dictTableName.currentText() ==
self.currentItem().parent().combo_box_dictTableName.currentText(),
self.list_of_dict_pref)
)[0]['columns']
if len(cur_table) == 1:
show_alarm_window(self, "You can't delete last element !!!")
return
cur_line = list(
filter(lambda x: x['colNameRow'].unique_name == self.currentItem().unique_name,
cur_table))[0]
cur_table.remove(cur_line)
self.currentItem().parent().takeChild(self.indexFromItem(self.currentItem()).row())
def delete_replace(self):
cur_column = list(
filter(lambda x: x['dictTableName'].combo_box_dictTableName.currentText() ==
self.currentItem().table_item.combo_box_dictTableName.currentText(),
self.list_of_dict_pref)
)[0]['columns']
element_in_list = list(
filter(lambda x: x['colNameRow'].combo_box.currentText() == self.currentItem().parent().combo_box.currentText(),
cur_column)
)[0]['replace_box']
if len(element_in_list) == 1:
show_alarm_window(self, "You can't delete last element !!!")
return
element_in_list.remove(self.currentItem())
self.currentItem().parent().takeChild(
self.indexFromItem(self.currentItem()).row())
def validatePage(self) -> bool:
if not self.excelFileName.text():
show_alarm_window(self, "Choose a source file !!!")
return False
else:
if self.change_flag is True or hasattr(self, "con") is False:
if hasattr(self, "con"):
self.con.closeConnect()
del self.con
self.wizard().page(1).comboBox_dbSchema.clear()
self.wizard().page(1).target_table_name.clear()
con = db_con.Connection.get_instance(self.loggerInst)
try:
con.connectToTheDB(host=self.lineEdit_dbhost.text(),
user=self.lineEdit_dbuser.text(),
password=self.lineEdit_dbpass.text(),
dbname=self.lineEdit_dbbase.text(),
port=int(self.lineEdit_dbport.text()),
dbtype=self.lineEdit_dbtype.currentText()
)
con.test_conn(0)
self.pref['dbtype'] = self.lineEdit_dbtype.currentText()
self.pref['dbHost'] = self.lineEdit_dbhost.text()
self.pref['dbUser'] = self.lineEdit_dbuser.text()
self.pref['dbPass'] = self.lineEdit_dbpass.text()
self.pref['dbBase'] = self.lineEdit_dbbase.text()
self.pref['dbPort'] = self.lineEdit_dbport.text()
self.pref['Load Mode'] = self.comboBox_chose_loadMode.currentText()
self.pref['excelFileName'] = self.excelFileName.text()
self.pref['comboBox_list_source_excel'] = self.comboBox_list_source_excel.currentIndex()
self.pref['checkBox_checkMode'] = self.checkBox_checkMode.isChecked()
self.pref['compare_file'] = self.compare_file.text()
self.pref['comboBox_set_list_checked'] = self.comboBox_set_list_checked.currentText()
self.pref['checkBox_Dictionary'] = self.checkBox_Dictionary.isChecked()
self.pref['checkBox_both'] = self.checkBox_both.isChecked()
except Exception:
if hasattr(self, "con"):
self.con.closeConnect()
show_alarm_window(self, "Can't connect to the DB !!!")
return False
else:
self.change_flag = False
self.con = con
self.initializePage2()
return True
else:
try:
self.con.test_conn(0)
except Exception:
if hasattr(self, "con"):
self.con.closeConnect()
show_alarm_window(self, "Can't connect to the DB !!!")
return False
return True
def add_link_col(self):
if self.df_compare:
target_column = [
i
for i in self.df_compare.parse(self.comboBox_set_list_checked.
currentIndex()).columns.values
]
else:
show_alarm_window(self, "Choose a file !!!")
return
source_column = [
i for i in self.df.parse(
self.comboBox_list_source_excel.currentIndex()).columns.values
]
row_check = LinkedColumns(tree_widget=self.treeWidget_linked_columns,
parent=self.treeWidget_linked_columns,
target_columns=target_column,
source_columns=source_column,
current_column=None)
self.treeWidget_linked_columns.addTopLevelItem(row_check)
self.pref['col_to_check'].append(row_check)
def error_at_create_xml(self, message):
show_alarm_window(self, message)
self.ui.statusbar.showMessage(f'Creating XML failed !')
def add_column(self):
if not self.itemWidget(self.currentItem().parent(), 1).currentText():
show_alarm_window(self, 'Select a table !!!')
return
dict_to_add = {}
cur_table = list(
filter(lambda x: x['dictTableName'].combo_box_dictTableName.currentText() ==
self.currentItem().parent().combo_box_dictTableName.currentText(),
self.list_of_dict_pref)
)[0]['columns']
for column in cur_table:
if column['colNameRow'].combo_box.currentText() == '---':
show_alarm_window(self, "Select column name !!!")
return
new_colName = dict_column_editor_viewer.ColumnNameRow(
column_property=self.dict_pref,
parent=self.currentItem().parent(),
tree_widget=self,
columns_names_source=self.columns_names_source,
after_widget=self.currentItem(),
adapter=self.adapter
)
self.addTopLevelItem(new_colName)
if not isinstance(self.validator, type):
colNameDbRow = dict_column_editor_viewer.ColumnNameDbRow(
column_property=self.dict_pref,
parent=new_colName,
tree_widget=self,
columns_in_receiver=self.validator.queryForColumns(),
adapter=self.adapter,
table_name=self.itemWidget(self.currentItem().parent(), 1),
validator=self.validator,
dbtype=self.dbtype,
db_base=self.db_base,
connector=self.connector,
executor=self.executor,
cur=self.cur,
loggerInst=self.loggerInst
)
else:
colNameDbRow = dict_column_editor_viewer.ColumnNameDbRow(
column_property=self.dict_pref,
parent=new_colName,
tree_widget=self,
columns_in_receiver=self.validator.queryForColumns_edit(
dbtype=self.dbtype,
target_table=self.itemWidget(self.currentItem().parent(), 1).currentText(),
db_base=self.db_base,
connector=self.connector,
executor=self.executor,
cur=self.cur,
loggerInst=self.loggerInst,
),
adapter=self.adapter,
table_name=self.itemWidget(self.currentItem().parent(), 1),
validator=self.validator,
dbtype=self.dbtype,
db_base=self.db_base,
connector=self.connector,
executor=self.executor,
cur=self.cur,
loggerInst=self.loggerInst
)
colTypeRow = dict_column_editor_viewer.ColTypeRow(
cur_dic_table_pref=self.dict_pref,
parent=new_colName,
tree_widget=self,
adapter=self.adapter)
cropEndRow = dict_column_editor_viewer.CropEndRow(
column_property=self.dict_pref,
parent=self,
parent_widget=new_colName,
adapter=self.adapter)
addValueEndRow = dict_column_editor_viewer.AddValueEndRow(
column_property=self.dict_pref,
parent=self,
parent_widget=new_colName,
adapter=self.adapter)
takeFromBeginRow = dict_column_editor_viewer.TakeFromBeginRow(
column_property=self.dict_pref,
parent=self,
parent_widget=new_colName,
adapter=self.adapter)
cropBeginRow = dict_column_editor_viewer.CropBeginRow(
column_property=self.dict_pref,
parent=self,
parent_widget=new_colName,
adapter=self.adapter)
addValueBeginRow = dict_column_editor_viewer.AddValueBeginRow(
column_property=self.dict_pref,
parent=self,
parent_widget=new_colName,
adapter=self.adapter)
addValueBothRow = dict_column_editor_viewer.AddValueBothRow(
column_property=self.dict_pref,
parent=self,
parent_widget=new_colName,
adapter=self.adapter)
replace_box = dict_column_editor_viewer.ReplaceRow(
row=None,
column_property=self.dict_pref,
parent=self,
parent_widget=new_colName,
after_widget=addValueBothRow,
table_item=None,
adapter=self.adapter
)
dict_to_add['replace_box'] = []
dict_to_add['replace_box'].append(replace_box)
dict_to_add['colNameRow'] = new_colName
dict_to_add['colNameDbRow'] = colNameDbRow
dict_to_add['colTypeRow'] = colTypeRow
dict_to_add['cropEndRow'] = cropEndRow
dict_to_add['addValueEndRow'] = addValueEndRow
dict_to_add['takeFromBeginRow'] = takeFromBeginRow
dict_to_add['cropBeginRow'] = cropBeginRow
dict_to_add['addValueBeginRow'] = addValueBeginRow
dict_to_add['addValueBothRow'] = addValueBothRow
cur_table.append(dict_to_add)
def select_config_file(self):
path_name_config = QtWidgets.QFileDialog.getOpenFileName(
directory=os.path.join(os.getcwd(), 'config'), filter='*.xml')
path = os.path.basename(path_name_config[0])
if path != '':
self.loggerInst = Logger.Log_info.getInstance(path, path)
self.tab_widget_editor.path = path
self.tab_widget_editor.path_name_config = path_name_config[0]
self.tab_widget_editor.ui.lineEdit_dbhost.clear()
self.tab_widget_editor.ui.lineEdit_dbuser.clear()
self.tab_widget_editor.ui.lineEdit_dbpass.clear()
self.tab_widget_editor.ui.lineEdit_dbbase.clear()
self.tab_widget_editor.ui.dbSchema.clear()
self.tab_widget_editor.ui.lineEdit_dbport.clear()
self.tab_widget_editor.ui.lineEdit_target_name.clear()
self.tab_widget_editor.ui.lineEdit_dbtype.clear()
self.tab_widget_editor.ui.comboBox_chose_loadMode.clear()
self.tab_widget_editor.ui.lineEdit_dbtype.addItems(
['mssql', 'mysql'])
self.tab_widget_editor.ui.comboBox_chose_loadMode.addItems(
['insert', 'update'])
try:
root = et.parse(path_name_config[0]).getroot()
except Exception as e:
try:
self.loggerInst.raiseError(1, e)
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.root = root
self.tab_widget_editor.tree = et.ElementTree(root)
try:
dbtype = root.find("dbtype").text
except:
try:
dbtype = et.SubElement(root, 'dbtype')
self.loggerInst.raiseError(3, "dbtype")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.lineEdit_dbtype.setCurrentText(
f"{dbtype}")
try:
loadMode = root.find("loadMode").text
except:
try:
loadMode = et.SubElement(root, 'loadMode')
self.loggerInst.raiseError(3, "loadMode")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.comboBox_chose_loadMode.setCurrentText(
f"{loadMode}")
try:
db_schema = root.find("dbSchema").text
except:
try:
db_schema = et.SubElement(root, 'dbSchema')
self.loggerInst.raiseError(4, "dbSchema")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.dbSchema.setText(f"{db_schema}")
try:
exportTableName_value_text = root.find("exportTable/path").text
except:
try:
exportTableName_value_text = et.SubElement(
root, 'exportTable/path')
self.loggerInst.raiseError(3, "exportTable/path")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.lineEdit_target_name.setText(
f"{exportTableName_value_text}")
try:
dbHost = root.find("dbHost").text
except:
try:
dbHost = et.SubElement(root, 'dbHost')
self.loggerInst.raiseError(3, "dbHost")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.lineEdit_dbhost.setText(f"{dbHost}")
try:
dbUser = root.find("dbUser").text
except:
try:
dbUser = et.SubElement(root, 'dbUser')
self.loggerInst.raiseError(3, "dbUser")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.lineEdit_dbuser.setText(f"{dbUser}")
try:
dbPass = root.find("dbPass").text
except:
try:
dbdbPassUser = et.SubElement(root, 'dbPass')
self.loggerInst.raiseError(3, "dbPass")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.lineEdit_dbpass.setText(f"{dbPass}")
try:
dbBase = root.find("dbBase").text
except:
try:
dbBase = et.SubElement(root, 'dbBase')
self.loggerInst.raiseError(3, "dbBase")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.lineEdit_dbbase.setText(f"{dbBase}")
try:
dbPort = root.find("dbPort").text
except:
try:
dbPort = et.SubElement(root, 'dbPort')
self.loggerInst.raiseError(3, "dbPort")
except Exception as e:
show_alarm_window(self, e)
else:
self.tab_widget_editor.ui.lineEdit_dbport.setText(f"{dbPort}")
self.ui.statusbar.showMessage(
f'Open config: {self.tab_widget_editor.path_name_config}')
