501 lines
19 KiB
Python
501 lines
19 KiB
Python
import os
|
|
|
|
from PySide6 import QtCore, QtGui, QtWidgets
|
|
from PySide6.QtCore import QDate
|
|
from PySide6.QtGui import QRegularExpressionValidator
|
|
|
|
from src import Icon
|
|
from src.backend import Database, recreateElsaFile
|
|
from src.logic import Prof, Semester, elsa_word_to_csv
|
|
from src.shared.logging import log
|
|
from src.ui.dialogs import ElsaAddEntry, popus_confirm
|
|
from src.ui.widgets.filepicker import FilePicker
|
|
from src.ui.widgets.graph import DataQtGraph
|
|
|
|
from .widget_sources.elsa_maindialog_ui import Ui_Dialog
|
|
|
|
|
|
class ElsaDialog(QtWidgets.QDialog, Ui_Dialog):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.setupUi(self)
|
|
self.table_elsa_list.setContextMenuPolicy(
|
|
QtCore.Qt.ContextMenuPolicy.CustomContextMenu
|
|
)
|
|
self.table_elsa_list.customContextMenuRequested.connect(self.elsa_context_menu)
|
|
# elsa buttons
|
|
Icon("semester", self.active_semester)
|
|
Icon("today", self.elsa_date_today)
|
|
self.create_frame_elsa.setEnabled(False)
|
|
self.elsa_add_new.clicked.connect(self.add_new_elsa)
|
|
self.elsa_cancel_create.clicked.connect(self.cancel_elsa_creation)
|
|
self.elsa_save.clicked.connect(self.save_elsa)
|
|
self.elsa_date_today.clicked.connect(self.generateTodayDateElsa)
|
|
self.active_semester.clicked.connect(self.addSemester)
|
|
self.elsa_update.clicked.connect(self.update_elsa)
|
|
self.elsa_table.doubleClicked.connect(self.open_elsa)
|
|
self.btn_add_document_elsa.clicked.connect(self.addDokumentElsa)
|
|
self.check_file_elsa.clicked.connect(self.parseDokumentElsa)
|
|
self.btn_open_document_elsa.clicked.connect(self.openDocumentElsa)
|
|
self.quote_entry.clicked.connect(self.elsa_table_entry)
|
|
self.quote_entry.setEnabled(False)
|
|
self.newProf.hide()
|
|
self.splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Horizontal)
|
|
self.splitter.addWidget(self.media_table)
|
|
self.splitter.addWidget(self.statistics)
|
|
self.results.layout().removeWidget(self.media_table)
|
|
self.results.layout().removeWidget(self.statistics)
|
|
self.results.layout().addWidget(self.splitter)
|
|
self.elsa_statistics_table.setColumnCount(2)
|
|
# set header to occupy the whole width and auto scale based on table width
|
|
self.elsa_statistics_table.horizontalHeader().setStretchLastSection(True)
|
|
self.elsa_statistics_table.horizontalHeader().setSectionResizeMode(
|
|
QtWidgets.QHeaderView.ResizeMode.Stretch
|
|
)
|
|
# if table size gets smaller, set horitzontal headers text to be left aligned
|
|
self.elsa_statistics_table.horizontalHeader().setDefaultAlignment(
|
|
QtCore.Qt.AlignmentFlag.AlignLeft
|
|
)
|
|
# self.table_elsa_list.
|
|
Icon("person", self.prof_icon)
|
|
# validators
|
|
# prof mail
|
|
self.newProf_mail.setValidator(
|
|
QRegularExpressionValidator(
|
|
QtCore.QRegularExpression(
|
|
r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}"
|
|
)
|
|
)
|
|
)
|
|
self.newProf_telnr.setValidator(QtGui.QIntValidator())
|
|
self.newProf_telnr.setValidator(
|
|
QtGui.QRegularExpressionValidator(QtCore.QRegularExpression(r"^\d{3,14}"))
|
|
)
|
|
|
|
##Variables
|
|
self.db = Database()
|
|
self.graph_data = {"x": [""], "y": [0]}
|
|
self.createProf = False
|
|
self.profs = self.getProfs()
|
|
|
|
self.elsa_prof.addItems([prof[0] for prof in self.profs])
|
|
self.elsa_prof.addItem("")
|
|
self.elsa_prof.setCurrentText("")
|
|
# implement a check for the prof name. if name is not in list and has schema of lastname, firstname, show newProf frame
|
|
self.elsa_prof.currentTextChanged.connect(self.checkProf)
|
|
self.newProf_mail.textChanged.connect(self.checkProfData)
|
|
self.newProf_telnr.textChanged.connect(self.checkProfData)
|
|
self.newProf_title.textChanged.connect(self.checkProfData)
|
|
|
|
self.loadFrame()
|
|
log.info("Elsa Dialog loaded")
|
|
# self.show()
|
|
|
|
def checkProfData(self):
|
|
if (
|
|
(self.newProf_mail.text() != "" and self.newProf_mail.hasAcceptableInput())
|
|
and self.newProf_title.text() != ""
|
|
and (
|
|
self.newProf_telnr.text() != ""
|
|
and self.newProf_telnr.hasAcceptableInput()
|
|
)
|
|
):
|
|
self.elsa_save.setEnabled(True)
|
|
self.elsa_save.setToolTip("")
|
|
self.newProf_mail.setToolTip("")
|
|
self.newProf_telnr.setToolTip("")
|
|
else:
|
|
self.elsa_save.setEnabled(False)
|
|
self.elsa_save.setToolTip("Bitte erst Daten eingeben")
|
|
self.newProf_mail.setToolTip("Bitte geben Sie eine gültige E-Mail ein")
|
|
self.newProf_telnr.setToolTip(
|
|
"Bitte geben Sie eine gültige Telefonnummer ein"
|
|
)
|
|
|
|
def checkProf(self):
|
|
if (
|
|
", " in self.elsa_prof.currentText()
|
|
and self.elsa_prof.currentText() not in [prof[0] for prof in self.profs]
|
|
):
|
|
self.newProf.show()
|
|
self.elsa_save.setEnabled(False)
|
|
self.elsa_save.setToolTip("Bitte erst Daten eingeben")
|
|
self.createProf = True
|
|
else:
|
|
self.newProf.hide()
|
|
self.createProf = False
|
|
self.elsa_save.setEnabled(True)
|
|
self.elsa_save.setToolTip("")
|
|
|
|
def getProfs(self):
|
|
profs = self.db.getProfs()
|
|
profs = [
|
|
("{}, {}".format(prof.lastname, prof.firstname), prof.id) for prof in profs
|
|
]
|
|
|
|
profs = list(set(profs))
|
|
profs.sort()
|
|
return profs
|
|
|
|
def elsa_context_menu(self, position):
|
|
QtWidgets.QMenu()
|
|
# TODO: add functions
|
|
pass
|
|
|
|
def elsa_table_entry(self):
|
|
data = ElsaAddEntry()
|
|
selected_row = self.table_elsa_list.currentRow()
|
|
signature = self.table_elsa_list.item(selected_row, 10).text()
|
|
mediatype = self.table_elsa_list.item(selected_row, 11).text()
|
|
pages = self.table_elsa_list.item(selected_row, 7).text().strip()
|
|
data.searchIdent.setText(signature)
|
|
match mediatype:
|
|
case "Monografien":
|
|
data.btn_mono.click()
|
|
case "Herausgeberwerke":
|
|
data.btn_hg.click()
|
|
case "Zeitschriftenaufsätze":
|
|
data.btn_zs.click()
|
|
if ";" in pages:
|
|
data.search()
|
|
else:
|
|
data.search(pages=pages)
|
|
data.exec()
|
|
|
|
def add_new_elsa(self):
|
|
self.create_frame_elsa.setEnabled(True)
|
|
self.elsa_cancel_create.setEnabled(True)
|
|
self.dokument_list_elsa.setRowCount(0)
|
|
|
|
self.elsa_save.setEnabled(True)
|
|
self.elsa_update.setEnabled(False)
|
|
self.elsa_prof.setFocus()
|
|
|
|
def cancel_elsa_creation(self):
|
|
self.create_frame_elsa.setEnabled(False)
|
|
self.elsa_cancel_create.setEnabled(False)
|
|
self.elsa_prof.setCurrentText("")
|
|
self.elsa_date.setText("")
|
|
self.elsa_semester.setText("")
|
|
self.dokument_list_elsa.setRowCount(0)
|
|
self.table_elsa_list.setRowCount(0)
|
|
self.quote_entry.setEnabled(False)
|
|
self.elsa_save.setEnabled(False)
|
|
self.elsa_update.setEnabled(False)
|
|
self.seperateEntries.setChecked(False)
|
|
|
|
def generateTodayDateElsa(self):
|
|
self.elsa_date.setText(QDate.currentDate().toString("dd.MM.yyyy"))
|
|
|
|
def addSemester(self):
|
|
self.elsa_semester.setText(Semester().value)
|
|
|
|
def update_elsa(self):
|
|
prof = self.elsa_prof.currentText()
|
|
date = self.elsa_date.text()
|
|
semester = self.elsa_semester.text()
|
|
elsa_id = self.db.getElsaId(prof, semester, date)
|
|
if elsa_id is None:
|
|
return
|
|
self.db.updateElsaApparat(elsa_id, prof, semester, date)
|
|
self.elsa_update.setEnabled(False)
|
|
self.cancel_elsa_creation()
|
|
|
|
def confirm_popup(self, message: str, title: str):
|
|
popup = popus_confirm(title=title)
|
|
popup.textEdit.setReadOnly(True)
|
|
popup.textEdit.setText(message)
|
|
|
|
popup.exec()
|
|
return popup.result()
|
|
|
|
def save_elsa(self):
|
|
if (
|
|
self.elsa_prof.currentText() == ""
|
|
or self.elsa_semester.text() == ""
|
|
or self.elsa_date.text() == ""
|
|
):
|
|
# warning message
|
|
self.confirm_popup("Bitte füllen Sie alle Felder aus", title="Fehler")
|
|
|
|
return
|
|
|
|
prof = self.elsa_prof.currentText()
|
|
semester = self.elsa_semester.text()
|
|
date = self.elsa_date.text()
|
|
profdata = Prof(
|
|
firstname=prof.split(", ")[1],
|
|
lastname=prof.split(", ")[0],
|
|
mail=self.newProf_mail.text(),
|
|
telnr=self.newProf_telnr.text(),
|
|
_title=self.newProf_title.text(),
|
|
fullname=f"{prof.split(', ')[0]} {prof.split(', ')[1]}",
|
|
)
|
|
prof_id = self.db.getProfId(profdata)
|
|
log.debug(f"ProfData: {profdata}, id:{prof_id}")
|
|
|
|
if prof_id is None:
|
|
self.db.createProf(profdata)
|
|
prof_id = self.db.getProfId(profdata)
|
|
self.profs.append(
|
|
"f{}, {}".format(profdata.lastname, profdata.firstname), prof_id
|
|
)
|
|
elsa_id = self.db.createElsaApparat(
|
|
date,
|
|
prof_id,
|
|
semester,
|
|
)
|
|
|
|
if self.dokument_list_elsa.rowCount() > 0:
|
|
files = []
|
|
for i in range(self.dokument_list_elsa.rowCount()):
|
|
filename = self.dokument_list_elsa.item(i, 0).text()
|
|
filetype = self.dokument_list_elsa.item(i, 1).text()
|
|
file_path = self.dokument_list_elsa.item(i, 3).text()
|
|
file = {"name": filename, "path": file_path, "type": filetype}
|
|
files.append(file)
|
|
self.db.insertElsaFile(
|
|
files,
|
|
elsa_id,
|
|
)
|
|
log.info("Stored {} files in the database", len(files))
|
|
self.cancel_elsa_creation()
|
|
self.refresh_elsa_table()
|
|
self.elsa_prof.setCurrentText("")
|
|
self.quote_entry.setEnabled(False)
|
|
log.info("Saved apparat to database, id {}", elsa_id)
|
|
|
|
def refresh_elsa_table(self):
|
|
self.elsa_table.setRowCount(0)
|
|
elsa_apparats = self.db.getElsaApparats()
|
|
for apparat in elsa_apparats:
|
|
self.insert_elsa_into_table(apparat)
|
|
|
|
def insert_elsa_into_table(self, apparat):
|
|
self.elsa_table.insertRow(0)
|
|
date = apparat[1]
|
|
semester = apparat[2]
|
|
prof = self.db.getProfNameById(apparat[3])
|
|
self.elsa_table.setItem(0, 0, QtWidgets.QTableWidgetItem(prof))
|
|
self.elsa_table.setItem(0, 1, QtWidgets.QTableWidgetItem(date))
|
|
self.elsa_table.setItem(0, 2, QtWidgets.QTableWidgetItem(semester))
|
|
return (semester, 1)
|
|
|
|
def open_elsa(self):
|
|
prof = self.elsa_table.item(self.elsa_table.currentRow(), 0).text()
|
|
log.info("prof", prof)
|
|
date = self.elsa_table.item(self.elsa_table.currentRow(), 1).text()
|
|
semester = self.elsa_table.item(self.elsa_table.currentRow(), 2).text()
|
|
self.elsa_update.setEnabled(True)
|
|
self.elsa_save.setEnabled(False)
|
|
if self.elsa_prof.currentText() == prof and date == self.elsa_date.text():
|
|
log.debug("Same prof, stopping")
|
|
return
|
|
self.create_frame_elsa.setEnabled(True)
|
|
self.dokument_list_elsa.setRowCount(0)
|
|
self.table_elsa_list.setRowCount(0)
|
|
self.elsa_cancel_create.setEnabled(True)
|
|
# get elsa apparats, iterate over them and find the one where all matches
|
|
elsa_apparats = self.db.getElsaApparats()
|
|
elsa_id = None
|
|
for apparat in elsa_apparats:
|
|
if (
|
|
apparat[1] == date
|
|
and apparat[2] == semester
|
|
and apparat[3] == self.db.getProfId({"profname": prof})
|
|
):
|
|
elsa_id = apparat[0]
|
|
break
|
|
self.elsa_date.setText(date)
|
|
self.elsa_semester.setText(semester)
|
|
self.elsa_prof.setCurrentText(prof)
|
|
log.info("Elsa ID is {}", elsa_id)
|
|
if elsa_id is None:
|
|
return
|
|
documents = self.db.getElsaFiles(elsa_id)
|
|
for document in documents:
|
|
self.dokument_list_elsa.insertRow(0)
|
|
self.dokument_list_elsa.setItem(
|
|
0, 0, QtWidgets.QTableWidgetItem(document[0])
|
|
)
|
|
self.dokument_list_elsa.setItem(
|
|
0, 1, QtWidgets.QTableWidgetItem(document[1])
|
|
)
|
|
self.dokument_list_elsa.setItem(0, 2, QtWidgets.QTableWidgetItem("❌"))
|
|
self.dokument_list_elsa.setItem(
|
|
0, 3, QtWidgets.QTableWidgetItem("Database")
|
|
)
|
|
scans = self.db.getElsaMedia(elsa_id)
|
|
if scans == []:
|
|
self.create_frame_elsa.setEnabled(True)
|
|
|
|
for scan in scans:
|
|
self.setElsaRow(scan)
|
|
|
|
self.quote_entry.setEnabled(True)
|
|
# self.cancel_elsa_creation()
|
|
|
|
def setElsaRow(self, scan):
|
|
self.table_elsa_list.insertRow(0)
|
|
self.table_elsa_list.setItem(
|
|
0, 0, QtWidgets.QTableWidgetItem(scan["work_author"])
|
|
)
|
|
self.table_elsa_list.setItem(
|
|
0, 1, QtWidgets.QTableWidgetItem(scan["section_author"])
|
|
)
|
|
self.table_elsa_list.setItem(0, 2, QtWidgets.QTableWidgetItem(scan["year"]))
|
|
self.table_elsa_list.setItem(0, 3, QtWidgets.QTableWidgetItem(scan["issue"]))
|
|
self.table_elsa_list.setItem(0, 4, QtWidgets.QTableWidgetItem(scan["edition"]))
|
|
self.table_elsa_list.setItem(
|
|
0, 5, QtWidgets.QTableWidgetItem(scan["work_title"])
|
|
)
|
|
self.table_elsa_list.setItem(
|
|
0, 6, QtWidgets.QTableWidgetItem(scan["chapter_title"])
|
|
)
|
|
self.table_elsa_list.setItem(
|
|
0,
|
|
7,
|
|
QtWidgets.QTableWidgetItem(scan["pages"]),
|
|
)
|
|
self.table_elsa_list.setItem(0, 8, QtWidgets.QTableWidgetItem(scan["location"]))
|
|
self.table_elsa_list.setItem(
|
|
0, 9, QtWidgets.QTableWidgetItem(scan["publisher"])
|
|
)
|
|
self.table_elsa_list.setItem(
|
|
0, 10, QtWidgets.QTableWidgetItem(scan["signature"])
|
|
)
|
|
self.table_elsa_list.setItem(0, 11, QtWidgets.QTableWidgetItem(scan["type"]))
|
|
|
|
def addDokumentElsa(self):
|
|
picker = FilePicker()
|
|
files = picker.pick_files()
|
|
datalist = []
|
|
for file in files:
|
|
data = {}
|
|
filename = file.split("/")[-1]
|
|
filetype = filename.split(".")[-1]
|
|
self.dokument_list_elsa.insertRow(0)
|
|
self.dokument_list_elsa.setItem(0, 0, QtWidgets.QTableWidgetItem(filename))
|
|
self.dokument_list_elsa.setItem(0, 1, QtWidgets.QTableWidgetItem(filetype))
|
|
self.dokument_list_elsa.setItem(0, 2, QtWidgets.QTableWidgetItem("*"))
|
|
self.dokument_list_elsa.setItem(0, 3, QtWidgets.QTableWidgetItem(file))
|
|
# set tooltip of row 3 to the file path for each row
|
|
self.dokument_list_elsa.item(0, 3).setToolTip(file)
|
|
data["name"] = filename
|
|
data["path"] = file
|
|
data["type"] = filetype
|
|
datalist.append(data)
|
|
|
|
def parseDokumentElsa(self):
|
|
if self.dokument_list_elsa.rowCount() == 0:
|
|
return
|
|
else:
|
|
# get the file path of the selected file based on it's row
|
|
row = self.dokument_list_elsa.currentRow()
|
|
file = self.dokument_list_elsa.item(row, 3).text()
|
|
file_location = file
|
|
if file == "Database":
|
|
filename = self.dokument_list_elsa.item(row, 0).text()
|
|
filetype = self.dokument_list_elsa.item(row, 1).text()
|
|
|
|
file = recreateElsaFile(
|
|
filename=filename, filetype=filetype, open=False
|
|
)
|
|
data, _ = elsa_word_to_csv(file)
|
|
elsa_id = self.db.getElsaId(
|
|
self.db.getProfId(Prof(fullname=self.elsa_prof.currentText())),
|
|
self.elsa_semester.text(),
|
|
self.elsa_date.text(),
|
|
)
|
|
log.debug(
|
|
f"elsa_id: {elsa_id}, prof: {self.elsa_prof.currentText()}, semester: {self.elsa_semester.text()}, date: {self.elsa_date.text()}"
|
|
)
|
|
if file_location != "Database":
|
|
self.db.insertElsaFile(
|
|
[
|
|
{
|
|
"name": file.split("/")[-1],
|
|
"path": file,
|
|
"type": file.split(".")[-1],
|
|
}
|
|
],
|
|
elsa_id,
|
|
)
|
|
for row in data:
|
|
if self.seperateEntries.isChecked():
|
|
if ";" in row["pages"]:
|
|
count = row["pages"].split(";")
|
|
for i in range(len(count)):
|
|
row["pages"] = count[i]
|
|
self.setElsaRow(
|
|
row,
|
|
)
|
|
self.db.addElsaMedia(row, elsa_id)
|
|
else:
|
|
self.setElsaRow(row)
|
|
self.db.addElsaMedia(row, elsa_id)
|
|
|
|
self.quote_entry.setEnabled(True)
|
|
|
|
def openDocumentElsa(self):
|
|
# open the selected document
|
|
row = self.dokument_list_elsa.currentRow()
|
|
location = self.dokument_list_elsa.item(row, 3).text()
|
|
filetype = self.dokument_list_elsa.item(row, 1).text()
|
|
filename = self.dokument_list_elsa.item(row, 0).text()
|
|
if location == "Database":
|
|
recreateElsaFile(filename, filetype, open=True)
|
|
else:
|
|
os.system(f"{filename}")
|
|
|
|
def loadFrame(self):
|
|
self.elsa_cancel_create.click()
|
|
try:
|
|
self.elsa_statistics.removeTab(1)
|
|
except:
|
|
log.debug("No tab to remove")
|
|
self.elsa_table.setRowCount(0)
|
|
elsa_apparats = self.db.getElsaApparats()
|
|
# elsa_apparats = natsorted(elsa_apparats, key=lambda x: x[2], reverse=True)
|
|
# x = semester, y = number of apparats
|
|
|
|
for apparat in elsa_apparats:
|
|
data = self.insert_elsa_into_table(apparat)
|
|
semester = data[0]
|
|
number = data[1]
|
|
if semester not in self.graph_data["x"]:
|
|
self.graph_data["x"].append(semester)
|
|
self.graph_data["y"].append(number)
|
|
else:
|
|
index = self.graph_data["x"].index(semester)
|
|
self.graph_data["y"][index] += number
|
|
self.graph_data["x"].pop(0)
|
|
self.graph_data["y"].pop(0)
|
|
# generateMissing = True if len(self.graph_data["x"]) > 2 else False
|
|
graph = DataQtGraph(
|
|
title="ELSA Apparate pro Semester",
|
|
data=self.graph_data,
|
|
generateMissing=False,
|
|
y_label="Anzahl der Apparate",
|
|
x_rotation=0,
|
|
)
|
|
log.debug(self.graph_data)
|
|
self.elsa_statistics_table.setRowCount(0)
|
|
for i in range(len(self.graph_data["x"])):
|
|
self.elsa_statistics_table.insertRow(0)
|
|
self.elsa_statistics_table.setItem(
|
|
0, 0, QtWidgets.QTableWidgetItem(self.graph_data["x"][i])
|
|
)
|
|
self.elsa_statistics_table.setItem(
|
|
0, 1, QtWidgets.QTableWidgetItem(str(self.graph_data["y"][i]))
|
|
)
|
|
self.elsa_statistics.addTab(graph, "Graph")
|
|
|
|
|
|
def launch():
|
|
log.debug("Launching Elsa Dialog")
|
|
app = QtWidgets.QApplication([])
|
|
window = ElsaDialog()
|
|
window.show()
|
|
app.exec()
|