151
return cmb.model().data(ind, Qt.EditRole)
def pre_ins_main(self, gotoUI=None):
ui = self.ui
d = self.data
#############################
# get data for insert
# ---------------------------
ufio = self.getComboBox0(ui.comboFIO)
vdate = ui.qle_date.date().toString("yyyy-MM-dd")
dep = self.data.dep
if ui.qleAmount.value() <= 0: # TODO: more checks
return
contr=self.data.get_contract(ufio, vdate, dep)
debug(contr)
qry_data = [
contr,
dep,
ufio,
self.getComboBox0(ui.comboServ),
vdate,
ui.qleAmount.value(),
self.getComboBox0(ui.comboW),
ui.qleNote.text()
]
self.ins_main(qry_data)
if gotoUI:
gotoUI.setFocus()
def ins_main(self, qry_data):
ui = self.ui
d = self.data
#############################
# check holiday
# ---------------------------
if qry_data:
pass
#############################
# insert
# ---------------------------
ret = self.data.si.insert_main_table(*qry_data)
ret, rid, err = ret
#############################
# check result
# ---------------------------
if ret:
if not ui.chkLFio.isChecked(): ui.comboFIO.setCurrentText("")
if not ui.chkLServ.isChecked(): ui.comboServ.setCurrentText("")
if not ui.chkLW.isChecked(): ui.comboW.setCurrentText("")
if not ui.chkLAmount.isChecked(): ui.qleAmount.setValue(0)
ui.qleNote.setText("")
mdl: tsSqlTableModel = d.models["dep_has_main_by_day"]
qry = QSqlQuery()
qry.exec_(mdl.qry_text)
qry.next()
mdl.setQuery(qry)
#d.models["dep_has_main_by_day"].selectRow(rid)
d.models["dep_has_main_by_day"].selectRow(rid)
# d.models["user_has_serv"].select()
152
# while (d.models["dep_has_main_by_day"].canFetchMore()):
# d.models["dep_has_main_by_day"].fetchMore()
else:
if "Out of range value for column 'contracts_id' at row 1" in err:
\n\n") + err
QMessageBox.critical(self,
ret)
@Slot()
def on_btn_serv_bydayW_clicked(self):
self.pre_ins_main(self.ui.comboW)
@Slot()
def on_btn_serv_bydayE_clicked(self):
self.pre_ins_main(self.ui.comboServ)
@Slot()
def on_btn_serv_bydayA_clicked(self):
self.pre_ins_main(self.ui.qleAmount)
def show(self, *args, **kwargs):
debug("show window")
# d=self.data
# if d.password and d.user :
# return self.check_login()
if self.login_done:
return super().show(*args, **kwargs)
else:
return self.check_login()
return self.dlg.show()
# ql1=QtWidgets.QLineEdit(dlg)
# dlg.formLayout.setItem(3,dlg.formLayout.ItemRole.FieldRole,ql1)
# dlg.formLayout.addRow(ql1)
# dlg.user.setClearButtonEnabled(True)
# dlg.password.setClearButtonEnabled(True)
def set3usonData(self, data):
self.data = data
@Slot()
def check_login(self):
""" show main window (to call from login dialog)
"""
d = self.data
d.user = self.dlg.user.text()
d.password = self.dlg.password.text()
# self.dep=self.dlg.dep.text()
ui = self.ui
if self.dbconnect():
self.login_done = True
self.show()
else:
self.dlg.show()
status: QPlainTextEdit = self.dlg.status
status.appendPlainText(self.data.db.lastError().text().strip())
# status.appendPlainText()
153
@Slot()
def selectDep(self):
"""popup list to select Department
"""
ui = self.ui
# self.depmenu=QtWidgets.QMenu(self)
# qry=QSqlQuery()
# qry.exec_("select dep_id, depName from worker_has_dep")
# while qry.next():
# self.depmenu.addAction(QtWidgets.QAction(""))
#
# for qa in
# self.depmenu.addAction(QtWidgets.QAction())
class MyPopup(QWidget):
def __init__(self):
QWidget.__init__(self)
# cbox=QComboBox(self)
cbox = QtWidgets.QListView()
self.m = QSqlTableModel()
self.m.setTable("worker_has_dep")
self.m.select()
# sql = "select dep from dep_has_user"
cbox.setModel(self.m)
# self.x
qry = QSqlQuery()
qry.exec_("select dep from depOFuser")
if qry.record().count() == 0:
error(" !")
elif qry.record().count() == 1:
index = qry.record().indexOf('dep_id')
qry.first()
self.setDep(qry.value(index))
else:
pass
self.dlgSelDep = MyPopup()
self.dlgSelDep.show()
@Slot()
def setDep(self, idDep, depName):
"""
"""
ui = self.ui
@Slot()
def setYear(self, year: int):
"""
"""
ui = self.ui
def assignModel(self, table: QtWidgets.QTableView, model) -> bool:
""" Connect @model to @table
Args:
self, table, model
"""
154
#############################
# assign table
# ---------------------------
if isinstance(model, str):
model = self.data.models[model]
if not model:
return False
table.horizontalHeader().setDefaultAlignment(Qt.AlignLeft)
table.setModel(model)
table.setTextElideMode(Qt.ElideRight)
delg = myItemDelegate(model)
table.setItemDelegate(delg)
# table.show()
return True
def on_btn_upd_fio_list(self):
ui = self.ui
d = self.data
mdl = ui.table_dep_has_ufio.model()
resetModel(mdl)
def make_connections(self) -> NoReturn:
ui = self.ui
ui.qaDBconnect.triggered.connect(self.dbconnect)
ui.qaDBDisconnect.triggered.connect(self.dbDisconnect)
ui.action_curDep.triggered.connect(self.selectDep)
dlg = self.dlg
dlg.btnEnter.accepted.connect(self.check_login)
dlg.btnEnter.rejected.connect(self.closeEvent)
@Slot()
def dbconnect(self):
"""connect to DB"""
if not self.data.createDBConnection():
db = self.data.db
if db.lastError().text().strip():
error(db.lastError().text())
# QMessageBox.critical(self, "Database Error",
# db.lastError().text())
return False
self.ui.action_connected_user.setText(self.tr(": ") + self.data.user)
self.notifiesToUsers()
self.findTablesAndCreateModels()
return True
def findTablesAndCreateModels(self):
"""init tables"""
#############################
# init tables ui
# ---------------------------
ui = self.ui
tList = self.tableList
for obj in self.findChildren(QtWidgets.QTableView): # why QTableView didn't work
name = obj.objectName()
if "table_" in name:
tList[obj.objectName()] = obj
tablesRTModel = self.tablesRTModel
# logging.getLogger(__name__).setLevel(logging.INFO)
info("ui table widgets: %s", tList.keys())
155
debug(QtWidgets.QTableView)
for key, obj in tList.items():
tname = key[6:]
if self.data.addModel(tname):
res = self.assignModel(obj, tname)
if res:
tablesRTModel[key]: obj
# debug("auto assignModel %s %s", tname, res)
logging.getLogger(__name__).setLevel(logging.DEBUG)
debug(tablesRTModel)
@Slot(bool)
def dbDisconnect(self, val):
# TODO:
QSqlDatabase.close(QSqlDatabase())
def notifiesToUsers(self):
debug("notifiesToUsers")
for nf in self.data.getNotifies():
QMessageBox.information(self.parent(),
self.tr(" "), nf)
def closeEvent(self, event):
info("closeEvent")
self.data.saveConfig()
qset = self.qsettings
qset.setValue("mw/geometry", self.saveGeometry())
qset.setValue("mw/windowState", self.saveState())
return super().closeEvent(event)
def readQSetting(self):
#############################
# set Font of app from config
# ---------------------------
try:
qset = self.qsettings
qfont: QFont = self.font()
qfont.setPointSize(int(qset.value("font_size", 8)))
QtWidgets.QApplication.instance().setFont(qfont)
self.restoreGeometry(qset.value("mw/geometry"))
self.restoreState(qset.value("mw/windowState"))
qset.setValue("geometry", self.saveGeometry())
qset.setValue("windowState", self.saveState())
except:
warning("settings loading failed")
class TsonData(QObject):
"""Manage and store Data"""
def __init__(self):
"""Constructor for 3sonData"""
super().__init__()
debug("TsonData init")
self.user = None
self.password = None
self.dep = None
self.server = None
156
self.port = None
#############################
# load local config file
# ---------------------------
try:
config = configparser.ConfigParser()
conf_path = os.path.join(home_dir, "3uson.conf")
if not os.path.exists(conf_path):
conf_path = "3uson.conf"
config.read(conf_path)
self.config = config
debug(config.sections())
self.user = self.config['DEFAULT']['lastuser']
self.server = self.config['DEFAULT']['server']
self.port = self.config['DEFAULT']['port']
# self.dep = self.config['DEFAULT']['lastdep']
self.password = self.config['DEFAULT']['DIRTY_HACK_FOR_DEBUG_SPW']
except:
error("config read error")
#############################
# init _sql_column_replace
# ---------------------------
tr = self.tr
self._sql_column_replace = {
"2ndpr
"contracts_id": tr(""),
"serv": tr(" "),
"ripso": tr(" "),
"dep": tr(" "),
"contracts": tr(""),
"uslnum": tr("- "),
"worker": tr(" "),
"worker_id": tr(""),
"ufio_id": tr(""),
"ufio": tr(" "),
157
-
"perc": tr("")
}
#############################
# init members
# ---------------------------
self.db: QSqlDatabase = None
self.notifies = []
#############################
# main models storage
# ---------------------------
self.models = {}
# self.init_main_model()
#############################
# some vars
# ---------------------------
self.si = self.servIns(self)
class servIns(QObject):
"""data and functions related to tab insert into main """
def __init__(self, parent):
"""Constructor for servIns"""
super().__init__(parent)
self.dbeg = None
self.dend = None
self.model_dep_has_main_by_day = None
self.model_dep_has_main_by_day_by_worker = None
self.model_dep_has_main_by_day_by_you = None
self.model_dep_has_main_by_day_by_serv = None
@staticmethod
def insert_main_table(*arg):
"""insert into main (contracts_id,
dep_id, ufio_id, serv_id,
vdate, uslnum, worker_id, note)"""
qry = QSqlQuery()
qry.prepare("""insert into main (contracts_id,
dep_id, ufio_id, serv_id,
vdate, uslnum, worker_id, note)
VALUES(?, ?, ?, ?, ?, ?, ?, ?)""")
for val in arg:
158
qry.addBindValue(val)
ret = qry.exec_()
rid=TsonData.line_query("SELECT LAST_INSERT_ID();")
return (ret, rid, qry.lastError().text().strip())
@staticmethod
def line_query(qry_str, val=0):
qry = QSqlQuery()
qry.exec_(qry_str)
qry.next()
return qry.value(val)
def init_main_model(self):
#############################
# create model
# ---------------------------
sqlTable = "servOFdep"
self.addModel(sqlTable)
def createDBConnection(self):
db = QSqlDatabase.addDatabase('QODBC3')
self.db = db
debug(QSqlDatabase.drivers())
user = self.user
if not self.server:
self.server = "127.0.0.1"
if not self.port:
self.port = "3306"
bdstr = "Driver={MySQL ODBC 8.0 Unicode Driver};" \
"SERVER=%s;DATABASE=kcson;UID=%s;PORT=%s" % \
(self.server, user, self.port)
db.setDatabaseName(bdstr)
debug(bdstr)
db.setUserName(user) # didn't work?
# db.setServer("127.0.0.1")
# db.setPort(3307)
info(user)
db.setPassword(self.password) # PWD=<password>"
res = db.open()
debug(res)
self.dep = self.line_query("select GET_DEP(GET_wID()) "
"as res", 0)
self.createUnAssignedModels()
return res
def createUnAssignedModels(self):
self.addModel("serv")
self.addModel("dep")
self.addModel("ufio")
self.addModel("serv")
self.addModel("serv_activ")
def closeDBConnection(self):
if self.db:
self.db.close()
self.db = None
def getNotifies(self) -> [str, ]:
"""
159
"""
try:
if self.db:
qry = QSqlQuery()
qry.exec_("SELECT msg from notifies "
"WHERE archive=0")
index = qry.record().indexOf('msg')
while qry.next():
yield qry.value(index)
else:
return None
except:
return None
def local_reports_compiler(self):
QSqlDatabase()
self.dbLocal = QSqlDatabase.addDatabase("QSQLITE", "conn1")
db1 = self.dbLocal
db1.setDatabaseName(":memory:")
if db1.open():
db = self.db
def addModel(self, modelName: str = None,
sql: str = None, sqlTable: str = None,
where: str = None) -> QSqlTableModel:
""" Create @model from @sql
Args:
self, modelName=None, sql=None,
sqlTable=None, where=None
Returns:
model or False
"""
if not (sql or sqlTable):
sqlTable = modelName
if not sql:
if sqlTable not in self.db.tables(QSql.AllTables):
return False
if not modelName: modelName = sqlTable
if not modelName: return False
debug("addModel %s to %s", modelName, sqlTable)
#############################
# create model
# ---------------------------
model: tsSqlTableModel = tsSqlTableModel(None, self.db)
try:
if sqlTable:
model.setTable(sqlTable)
if where:
model.setFilter(where)
elif sql:
qry = QSqlQuery()
qry.exec_(sql)
qry.next()
model.qry_text = sql
model.setQuery(qry)
model.setEditStrategy(QSqlTableModel.OnManualSubmit)
model.select()
160
except:
warning("addModel bad sql %s",
(modelName, sql, sqlTable))
return False
#############################
# replace sql column names
# ---------------------------
for i in range(0, model.columnCount()):
label = model.headerData(i, Qt.Horizontal)
if label in self._sql_column_replace.keys():
label = self._sql_column_replace[label]
model.setHeaderData(i, Qt.Horizontal, label)
#############################
# add model to dict
# ---------------------------
self.models[modelName] = model
return model
def convColName(self, colName: str) -> str:
"""
Args:
original SQL column Name
Returns:
new column Name
"""
try:
if self._sql_column_replace[colName]:
return self._sql_column_replace[colName]
except:
return colName
def setFilterCol(self, table: QTableView, colName, model=None):
"""Prepare filter model if needed and set column for filtering"""
if not model:
model = table.model()
if isinstance(model, tsSqlTableModel):
newmdl = QSortFilterProxyModel()
newmdl.setSourceModel(model)
table.setModel(newmdl)
model = newmdl
smdl: tsSqlTableModel = model.sourceModel()
while not isinstance(smdl, tsSqlTableModel):
smdl = smdl.sourceModel()
# orig = self.convColName(colName)
col = smdl.tsFieldNames.index(colName)
model.setFilterKeyColumn(col)
return model
def saveConfig(self):
"""Save config file
"""
debug("saveConfig")
config = self.config
config['DEFAULT']['lastuser'] = self.user
config['DEFAULT']['dep'] = str(self.dep)
conf_path = os.path.join(home_dir, "3uson.conf")
try:
with open(conf_path, 'w', encoding='utf-8') as conf_file:
config.write(conf_file)