class SonstigeAusgabenView(IccView):
def __init__(self, parent=None):
IccView.__init__(self)
#self.setWindowTitle( "Sonstige Ausgaben: Rechnungen, Abgaben, Gebühren etc." )
self._mainLayout = QtWidgets.QGridLayout(self)
self._toolbarLayout = QHBoxLayout()
self._summenLayout = QHBoxLayout()
self._btnSave = QPushButton(self)
self._btnComplexSort = QPushButton()
self._editSearch = QLineEdit(self)
self._btnSearchFwd = QPushButton(self)
self._btnDbSearch = QPushButton(self)
self._cboBuchungsjahr = QtWidgets.QComboBox(self)
self._tvAuszahlungen = TableViewExt(self)
self._buchungsdatumLayout = QHBoxLayout()
self._sdBuchungsdatum = SmartDateEdit(self)
self._btnAddDay = QPushButton(self)
self._btnClearBuchungsdatum = QPushButton(self)
self._objektRefLayout = QHBoxLayout()
self._cboMasterobjekt = QComboBox(self)
self._cboMietobjekt = QComboBox(self)
self._editRechnungLineLayout = QHBoxLayout()
self._cboKreditor = EditableCombo(self)
self._cboBuchungstext = EditableCombo(self)
self._sdRechnungsdatum = SmartDateEdit(self)
self._feBetrag = FloatEdit(self)
self._cboKostenart = QComboBox(self)
self._cbUmlegbar = QCheckBox(self)
self._cbWerterhaltend = QCheckBox(self)
self._teBemerkung = QTextEdit(self)
self._btnOk = QPushButton(self)
self._btnClear = QPushButton(self)
# Callbacks
self._buchungsjahrChangedCallback = None
self._saveActionCallback = None
self._searchActionCallback = None
self._dbSearchActionCallback = None
self._masterobjektChangedCallback = None
self._mietobjektChangedCallback = None
self._kreditorChangedCallback = None
self._submitChangesCallback = None
self._justEditing: XSonstAus = None
self._suspendCallbacks = False
self._createGui()
def _createGui(self):
self._assembleToolbar()
self._mainLayout.addLayout(self._toolbarLayout,
0,
0,
alignment=Qt.AlignLeft)
#self._assembleSummen()
# self._toolbarLayout.addStretch( 50 )
# self._toolbarLayout.addLayout( self._summenLayout )
### tableView
tv = self._tvAuszahlungen
tv.setSelectionBehavior(QAbstractItemView.SelectRows)
tv.setAlternatingRowColors(True)
tv.verticalHeader().setVisible(False)
tv.horizontalHeader().setMinimumSectionSize(0)
self._mainLayout.addWidget(tv, 1, 0, 1, 1)
self._assembleBuchungsUndRechnungsdatum()
self._mainLayout.addLayout(self._buchungsdatumLayout,
2,
0,
alignment=Qt.AlignLeft)
self._assembleObjektReference()
self._mainLayout.addLayout(self._objektRefLayout,
3,
0,
alignment=Qt.AlignLeft)
self._assembleRechnungsdaten()
self._mainLayout.addLayout(self._editRechnungLineLayout,
4,
0,
alignment=Qt.AlignLeft)
def _assembleToolbar(self):
#### Combobox Buchungsjahr
font = QFont("Arial", 14, weight=QFont.Bold)
self._cboBuchungsjahr.setFont(font)
self._cboBuchungsjahr.setToolTip(
"Das hier eingestellte Jahr bestimmt die Rechnungen, die in der Tabelle angezeigt werden."
)
self._cboBuchungsjahr.currentIndexChanged.connect(
self.onBuchungsjahrChanged)
self._toolbarLayout.addWidget(self._cboBuchungsjahr,
stretch=0,
alignment=Qt.AlignLeft)
#### save button
btn = self._btnSave
btn.clicked.connect(self.onSave)
btn.setFlat(True)
btn.setEnabled(False)
btn.setToolTip("Änderungen dieser View speichern")
icon = QIcon(ICON_DIR + "save_30.png")
btn.setIcon(icon)
size = QSize(30, 30)
btn.setFixedSize(size)
iconsize = QSize(30, 30)
btn.setIconSize(iconsize)
self._toolbarLayout.addWidget(btn, stretch=0)
### complex sort button
btn = self._btnComplexSort
btn.clicked.connect(self.onSortComplex)
btn.setFlat(True)
btn.setEnabled(True)
btn.setToolTip(
"Nach Master, Kostenart, Kreditor, Mietobjekt, Buchungsdatum sortieren"
)
icon = QIcon(ICON_DIR + "sort.png")
btn.setIcon(icon)
size = QSize(30, 30)
btn.setFixedSize(size)
iconsize = QSize(30, 30)
btn.setIconSize(iconsize)
self._toolbarLayout.addWidget(btn, stretch=0)
### search field for tableview search
edi = self._editSearch
edi.setPlaceholderText("Suche in Tabelle")
edi.returnPressed.connect(self._onSearch)
edi.setToolTip("Suchbegriff eingeben")
self._toolbarLayout.addWidget(edi, stretch=0)
btn = self._btnSearchFwd
btn.clicked.connect(self._onSearch)
size = QSize(30, 30)
btn.setFixedSize(size)
btn.setToolTip("Suche nach eingegebenem Begriff")
icon = QIcon(ICON_DIR + "arrow_dn_30.png")
btn.setIcon(icon)
btn.setEnabled(True)
self._toolbarLayout.addWidget(btn, stretch=0)
def _assembleBuchungsUndRechnungsdatum(self):
lbl = QLabel(self, text="Buchungsdatum: ")
lbl.setFixedWidth(150)
self._buchungsdatumLayout.addWidget(lbl)
self._sdBuchungsdatum.setFixedWidth(85)
self._sdBuchungsdatum.setToolTip(
"Buchungsdatum. Kann leer bleiben, wenn Buchung noch nicht erfolgt ist"
)
self._buchungsdatumLayout.addWidget(self._sdBuchungsdatum)
size = QSize(25, 25)
self._btnAddDay.setIcon(QIcon(ICON_DIR + "plus.png"))
self._btnAddDay.setFixedSize(size)
self._btnAddDay.setToolTip("Buchungsdatum um 1 Tag erhöhen")
self._btnAddDay.clicked.connect(self.onAddDayToBuchungsdatum)
self._buchungsdatumLayout.addWidget(self._btnAddDay)
self._btnClearBuchungsdatum.setIcon(QIcon(ICON_DIR + "cancel.png"))
self._btnClearBuchungsdatum.setFixedSize(size)
self._btnClearBuchungsdatum.setToolTip("Buchungsdatum löschen")
self._btnClearBuchungsdatum.clicked.connect(self.onClearBuchungsdatum)
self._buchungsdatumLayout.addWidget(self._btnClearBuchungsdatum)
self._sdRechnungsdatum.setPlaceholderText("Datum Rg.")
self._sdRechnungsdatum.setMaximumWidth(85)
self._sdRechnungsdatum.setToolTip("optional: Datum der Rechnung")
self._buchungsdatumLayout.addSpacing(10)
lbl = QLabel(text="Rechnungsdatum (optional): ")
lbl.setFixedWidth(200)
self._buchungsdatumLayout.addWidget(lbl)
self._buchungsdatumLayout.addWidget(self._sdRechnungsdatum)
def _assembleObjektReference(self):
lbl = QLabel(self, text="Betroffenes Objekt: ")
lbl.setFixedWidth(150)
self._objektRefLayout.addWidget(lbl)
self._cboMasterobjekt.setFixedWidth(155)
self._cboMasterobjekt.setPlaceholderText("Haus")
self._cboMasterobjekt.setToolTip(
"Haus, auf das sich die Zahlung bezieht")
self._cboMasterobjekt.currentIndexChanged.connect(
self.onMasterobjektChanged)
self._objektRefLayout.addWidget(self._cboMasterobjekt)
self._cboMietobjekt.setPlaceholderText("Wohnung")
self._cboMietobjekt.setToolTip(
"optional: Wohnung, auf die sich die Zahlung bezieht")
self._cboMietobjekt.currentIndexChanged.connect(
self.onMietobjektChanged)
self._objektRefLayout.addWidget(self._cboMietobjekt)
def _assembleRechnungsdaten(self):
self._cboKreditor.setToolTip("Kreditor")
self._cboKreditor.setFixedWidth(200)
self._cboKreditor.currentIndexChanged.connect(self.onKreditorChanged)
self._editRechnungLineLayout.addWidget(self._cboKreditor)
self._cboBuchungstext.setToolTip(
"Identifikation der Zahlung durch Rechnungsnummer oder Buchungstext"
)
self._cboBuchungstext.setMinimumWidth(100)
self._editRechnungLineLayout.addWidget(self._cboBuchungstext,
stretch=2)
#Button for DB-Search
btn = self._btnDbSearch
btn.clicked.connect(self._onDbSearch)
size = QSize(30, 30)
btn.setFixedSize(size)
btn.setToolTip("Suche Buchungstext in der DB")
icon = QIcon(ICON_DIR + "search_30.png")
btn.setIcon(icon)
btn.setEnabled(True)
self._editRechnungLineLayout.addWidget(btn)
# Betragsfeld
self._feBetrag.setPlaceholderText("Betrag")
self._feBetrag.setMaximumWidth(70)
self._feBetrag.setToolTip(
"Positive Beträge sind Aus-, negative Einzahlungen (Gutschriften)")
self._editRechnungLineLayout.addWidget(self._feBetrag,
stretch=0,
alignment=Qt.AlignLeft)
# Combobox Kostenart
self._cboKostenart.setPlaceholderText("Kostenart")
self._cboKostenart.setFixedWidth(120)
self._cboKostenart.setToolTip("Kostenart einstellen")
self._editRechnungLineLayout.addWidget(self._cboKostenart,
stretch=0,
alignment=Qt.AlignLeft)
vbox = QVBoxLayout()
vbox.setSpacing(0)
self._cbUmlegbar.setText("uml")
self._cbUmlegbar.setToolTip(
"Ob die Auszahlung auf den/die Mieter umlegbar sind")
vbox.addWidget(self._cbUmlegbar)
self._cbWerterhaltend.setText("wert")
self._cbWerterhaltend.setToolTip(
"Ob die Auszahlung der Werterhaltung der Wohnung dient")
vbox.addWidget(self._cbWerterhaltend)
self._editRechnungLineLayout.addLayout(vbox)
self._teBemerkung.setPlaceholderText("Bemerkung zur Auszahlung")
self._teBemerkung.setMaximumSize(QtCore.QSize(16777215, 50))
self._editRechnungLineLayout.addWidget(self._teBemerkung, stretch=1)
vbox = QVBoxLayout()
self._btnOk.setIcon(QIcon(ICON_DIR + "checked.png"))
self._btnOk.setDefault(True)
self._btnOk.setToolTip(
"Neue oder geänderte Daten in Tabelle übernehmen (kein Speichern)")
self._btnOk.clicked.connect(self.onOkEditFields)
vbox.addWidget(self._btnOk)
self._btnClear.setIcon(QIcon(ICON_DIR + "cancel.png"))
self._btnClear.setToolTip("Änderungen verwerfen und Felder leeren")
self._btnClear.clicked.connect(self.onClearEditFields)
vbox.addWidget(self._btnClear)
self._editRechnungLineLayout.addLayout(vbox)
# def setContextMenuActions( self, actions:List[QAction] ) -> None:
# self._contextMenuActions = actions
def getSummen(self) -> XSonstAusSummen:
summen = XSonstAusSummen()
summen.summe_aus = self._idSummeAus.getIntValue()
summen.summe_werterhaltend = self._idSummeW.getIntValue()
summen.summe_umlegbar = self._idSummeU.getIntValue()
return summen
def onAddDayToBuchungsdatum(self):
val = self._sdBuchungsdatum.getDate()
if val:
dt = getQDateFromIsoString(val)
dt = dt.addDays(1)
self._sdBuchungsdatum.setDate(dt.year(), dt.month(), dt.day())
def onClearBuchungsdatum(self):
self._sdBuchungsdatum.clear()
def setSaveButtonEnabled(self, enable: bool = True):
self._btnSave.setEnabled(enable)
def onSave(self):
if self._saveActionCallback:
self._saveActionCallback()
def onSortComplex(self):
sortoption1 = ("master_name", "kostenart", "kreditor", "mobj_id",
"buchungsdatum")
tm: SonstAusTableModel = self.getModel()
tm.sortComplex(sortoption1)
def _onSearch(self):
if self._searchActionCallback:
self._searchActionCallback(self._editSearch.text())
def _onDbSearch(self):
if self._dbSearchActionCallback:
#self._dbSearchActionCallback( self._editDbSearch.text() )
searchstring = self._cboBuchungstext.currentText()
if searchstring:
self._dbSearchActionCallback(searchstring)
def onBuchungsjahrChanged(self, newindex):
"""
Slot für die Änderung des Buchungsjahrs.
:param newindex:
:return:
"""
if self._buchungsjahrChangedCallback:
jahr = int(self._cboBuchungsjahr.currentText())
self._buchungsjahrChangedCallback(jahr)
def onMasterobjektChanged(self, newindex: int):
if self._masterobjektChangedCallback and not self._suspendCallbacks:
self._masterobjektChangedCallback(
self._cboMasterobjekt.currentText())
def onMietobjektChanged(self, newindex: int):
pass
def onKreditorChanged(self, newindex: int):
if self._kreditorChangedCallback and not self._suspendCallbacks:
self._kreditorChangedCallback(self._cboMasterobjekt.currentText(),
self._cboMietobjekt.currentText(),
self._cboKreditor.currentText())
def onOkEditFields(self, arg):
"""
OK gedrückt. Änderungen an Callback-Funktion melden.
:param arg:
:return:
"""
if self._submitChangesCallback:
x: XSonstAus = self._getEditedXSonstAus()
ok: bool = self._submitChangesCallback(x)
if ok:
self._tvAuszahlungen.clearSelection()
if x.saus_id <= 0: # neuer Eintrag in Tabelle, nach unten scrollen
self._tvAuszahlungen.scrollToBottom()
def _getEditedXSonstAus(self) -> XSonstAus:
x: XSonstAus = self._justEditing if self._justEditing else XSonstAus()
x.buchungsjahr = int(self._cboBuchungsjahr.currentText())
x.buchungsdatum = self._sdBuchungsdatum.getDate()
idx = self._cboMasterobjekt.currentIndex()
x.master_name = "" if idx < 0 else self._cboMasterobjekt.currentText()
idx = self._cboMietobjekt.currentIndex()
x.mobj_id = "" if idx < 0 else self._cboMietobjekt.currentText()
x.kreditor = self._cboKreditor.currentText()
x.buchungstext = self._cboBuchungstext.currentText()
x.rgdatum = self._sdRechnungsdatum.getDate()
x.betrag = self._feBetrag.getFloatValue() * (-1)
x.kostenart_lang = self._cboKostenart.currentText()
x.umlegbar = self._cbUmlegbar.isChecked()
x.werterhaltend = self._cbWerterhaltend.isChecked()
x.rgtext = self._teBemerkung.toPlainText()
return x
def onClearEditFields(self, arg):
self.clearEditFields()
self._tvAuszahlungen.clearSelection()
def getAuszahlungenTableView(self) -> QTableView:
return self._tvAuszahlungen
def setAuszahlungenTableModel(self, tm: SonstAusTableModel):
self._tvAuszahlungen.setModel(tm)
self._tvAuszahlungen.resizeColumnsToContents()
#self._tvAuszahlungen.setColumnWidth( 0, 10 )
#self._tvAuszahlungen.setColumnWidth( 1, 10 )
def setBuchungsjahre(self, jahre: List[int]):
"""
setzt die Liste der auswählbaren Jahre für die Buchungsjahr-Combobox
:param jahre:
:return:
"""
for jahr in jahre:
self._cboBuchungsjahr.addItem(str(jahr))
def setBuchungsjahr(self, jahr: int) -> None:
"""
setzt das Jahr, das in der Buchungsjahr-Combobox anzuzeigen ist
:param jahr:
:return:
"""
self._cboBuchungsjahr.setCurrentText(str(jahr))
def setBuchungsdatum(self, tag: int, monat: str):
"""
setzt Buchungstag und -monat.
Das Jahr ergibt sich aus dem eingestellten Buchungsjahr
:param tag:
:param monat:
:return:
"""
# self._sbTag.setValue( tag )
# self._cboMonat.setCurrentText( monat )
self._sdBuchungsdatum.\
setDate( int(self._cboBuchungsjahr.currentText()), getMonthIndex( monat ), tag )
def setMasterobjekte(self, masterobjekte: List[str]):
for obj in masterobjekte:
self._cboMasterobjekt.addItem(obj)
def setMietobjekte(self, mietobjekte: List[str]):
self._cboMietobjekt.clear()
for obj in mietobjekte:
self._cboMietobjekt.addItem(obj)
self._cboMietobjekt.setCurrentIndex(0)
def selectMietobjekt(self, mobj_id: str):
self._cboMietobjekt.setCurrentText(mobj_id)
def clearMietobjekte(self):
self._cboMietobjekt.clear()
def setKreditoren(self, kreditoren: List[str]):
self._cboKreditor.clear()
for k in kreditoren:
self._cboKreditor.addItem(k)
self._cboKreditor.setCurrentIndex(-1)
def selectKreditor(self, kreditor: str):
self._cboKreditor.setCurrentText(kreditor)
def setLeistungsidentifikationen(self, idents: List[str]):
self._cboBuchungstext.clear()
for i in idents:
self._cboBuchungstext.addItem(i)
#self._cboRechnungsIdent.showPopup()
def setCurrentLeistungsidentifikation(self, leistident: str) -> None:
self._cboBuchungstext.setCurrentText(leistident)
def getCurrentMasterobjekt(self) -> str:
return self._cboMasterobjekt.currentText()
def getCurrentMietobjekt(self) -> str:
return self._cboMietobjekt.currentText()
def getCurrentKreditor(self) -> str:
return self._cboKreditor.currentText()
def setCurrentKreditor(self, kreditor: str) -> None:
self._cboKreditor.setCurrentText(kreditor)
def getCurrentLeistungsidentifikation(self) -> str:
return self._cboBuchungstext.currentText()
def resetKreditoren(self):
self._cboKreditor.setCurrentIndex(-1)
def clearKreditoren(self):
self._cboKreditor.clear()
def setKostenarten(self, kostenarten: List[str]):
self._cboKostenart.clear()
for k in kostenarten:
self._cboKostenart.addItem(k)
self._cboKostenart.setCurrentIndex(-1)
def getCurrentKostenart(self) -> str:
return self._cboKostenart.currentText()
def selectKostenart(self, kostenart: str):
self._cboKostenart.setCurrentText(kostenart)
def resetKostenart(self):
self._cboKostenart.setCurrentIndex(-1)
def clearEditFields(self):
self._suspendCallbacks = True
self._sdBuchungsdatum.clear()
self._cboMasterobjekt.setCurrentIndex(-1)
self._cboMietobjekt.setCurrentIndex(-1)
self._cboKreditor.setCurrentIndex(-1)
self._cboBuchungstext.setCurrentIndex(-1)
self._sdRechnungsdatum.clear()
self._feBetrag.clear()
self._cboKostenart.setCurrentIndex(-1)
self._cbUmlegbar.setChecked(False)
self._cbWerterhaltend.setChecked(False)
self._teBemerkung.clear()
self._justEditing = None
self._suspendCallbacks = False
def provideEditFieldsPartly(self, umlegbar: bool, master_id: int,
master_name: str, mobj_id: str, kreditor: str,
kostenart_lang: str, buchungstext: str):
self._cbUmlegbar.setChecked(umlegbar)
self._cboMasterobjekt.setCurrentText(master_name)
self._cboMietobjekt.setCurrentText(mobj_id)
self._cboKreditor.setCurrentText(kreditor)
self._cboBuchungstext.setCurrentText(buchungstext)
self._cboKostenart.setCurrentText(kostenart_lang)
#todo: weitermachen
def provideEditFields(self, x: XSonstAus):
self.clearEditFields()
#self._suspendCallbacks = True
self._justEditing = x
if x.buchungsdatum:
y, m, d = getDateParts(x.buchungsdatum)
self._sdBuchungsdatum.setDate(y, m, d)
else:
self._sdBuchungsdatum.clear()
if x.master_id is not None and x.master_id >= 0: #master_id kann auch 0 sein! (**alle**)
self._cboMasterobjekt.setCurrentText(x.master_name)
if x.mobj_id:
self._cboMietobjekt.setCurrentText(x.mobj_id)
if x.kreditor:
self._cboKreditor.setCurrentText(x.kreditor)
if x.kostenart:
self._cboKostenart.setCurrentText(x.kostenart_lang)
if x.buchungstext:
self._cboBuchungstext.setCurrentText(x.buchungstext)
if x.rgdatum:
y, m, d = getDateParts(x.rgdatum)
self._sdRechnungsdatum.setDate(y, m, d)
self._feBetrag.setText(str(x.betrag * (-1)))
self._cbUmlegbar.setChecked(x.umlegbar)
self._cbWerterhaltend.setChecked(x.werterhaltend)
self._teBemerkung.setText(x.rgtext)
self._suspendCallbacks = False
def getModel(self) -> IccTableModel:
return self._tvAuszahlungen.model()
def showException(self, title: str, exception: str, moretext: str = None):
# todo: show Qt-Errordialog
msgbox = QtWidgets.QMessageBox()
msgbox.setWindowTitle(title)
msgbox.setIcon(QMessageBox.Critical)
msgbox.setText(exception)
if moretext:
msgbox.setInformativeText(moretext)
msgbox.exec_()
################# SET CALLBACKS ############################
def setBuchungsjahrChangedCallback(self, cbfnc) -> None:
"""
Die callback-Funktion muss als Argument das neu eingestellte Jahr als integer akzeptieren
:param cbfnc:
:return:
"""
self._buchungsjahrChangedCallback = cbfnc
def setSaveActionCallback(self, cbfnc) -> None:
"""
Die callback-FUnktion braucht keine Parameter empfangen.
:param cbfnc:
:return:
"""
self._saveActionCallback = cbfnc
def setSearchActionCallback(self, cbfnc) -> None:
"""
Die callback-Funktion muss den Searchstring als Parameter empfangen.
:param cbfnc:
:return:
"""
self._searchActionCallback = cbfnc
def setDbSearchActionCallback(self, cbfnc) -> None:
"""
Die callback-Funktion muss den Searchstring als Parameter empfangen.
:param cbfnc:
:return:
"""
self._dbSearchActionCallback = cbfnc
def setMasterobjektChangedCallback(self, cbfnc):
"""
Die callback-Funktion muss einen String als Argument akzeptieren (Name des MAsterobjekts)
:param cbfnc:
:return:
"""
self._masterobjektChangedCallback = cbfnc
def setMietobjektChangedCallback(self, cbfnc):
"""
Die callback-Funktion muss einen String als Argument akzeptieren (mobj_id)
:param cbfnc:
:return:
"""
self._mietobjektChangedCallback = cbfnc
def setKreditorChangedCallback(self, cbfnc):
"""
Die callback Funktion muss 3 Argumente entgegennehmen können:
master_name, mobj_id, neuer kreditor
:param cbfnc:
:return:
"""
self._kreditorChangedCallback = cbfnc
def setSubmitChangesCallback(self, cbfnc):
"""
sets the one and only callback when the user hits the OK button in the
edit fields area.
The given callback function has to accept the edited XSonstAus object,
:param cbfnc:
:return:
"""
self._submitChangesCallback = cbfnc
class OffenerPostenEditor( QWidget ):
"""
Zum Editieren eines einzelnen Offenen Postens.
"""
debiKrediAuswahlFirmaPressed = Signal()
debiKrediAuswahlVwPressed = Signal()
def __init__( self, x:XOffenerPosten, parent=None ):
QWidget.__init__( self, parent )
self._layout = QGridLayout()
self.setLayout( self._layout )
self._erfasstAm = SmartDateEdit()
self._debiKredi = QLineEdit()
self._btnAuswahlDebiKredi_Firma = QPushButton( text="..." )
self._btnAuswahlDebiKredi_Firma.clicked.connect( self._onDebiKrediAuswahl_Firma )
self._btnAuswahlDebiKredi_Vw = QPushButton( text="..." )
self._btnAuswahlDebiKredi_Vw.clicked.connect( self._onDebiKrediAuswahl_Vw )
self._betrag = FloatEdit()
self._betragBeglichen = FloatEdit()
self._letzteBuchungAm = SmartDateEdit()
self._bemerkung = QPlainTextEdit()
self._offenerPosten:XOffenerPosten = x
self._createGui()
self._dataToGui()
def _createGui( self ):
r = c = 0
l = self._layout
self._erfasstAm.setPlaceholderText( "erfasst am" )
self._erfasstAm.setToolTip( "Erfassungsdatum des Offenen Postens" )
self._erfasstAm.setMaximumWidth( 90 )
l.addWidget( self._erfasstAm, r, c )
c += 1
self._debiKredi.setMinimumWidth( 250 )
self._debiKredi.setPlaceholderText( "Debitor oder Kreditor" )
self._debiKredi.setToolTip( "Debitor oder Kreditor eintragen" )
l.addWidget( self._debiKredi, r, c )
c += 1
vbox = QVBoxLayout()
vbox.addWidget( self._btnAuswahlDebiKredi_Firma )
self._btnAuswahlDebiKredi_Firma.setFixedSize( QSize( 30, 30 ) )
self._btnAuswahlDebiKredi_Firma.setToolTip( "Öffnet einen Dialog zur Auswahl einer Firma "
"als Debitor oder Kreditor" )
vbox.addWidget( self._btnAuswahlDebiKredi_Vw )
self._btnAuswahlDebiKredi_Vw.setFixedSize( QSize( 30, 30 ) )
self._btnAuswahlDebiKredi_Vw.setToolTip( "Öffnet einen Dialog zur Auswahl eines Verwalters "
"als Debitor oder Kreditor" )
l.addLayout( vbox, r, c )
#l.addWidget( self._btnAuswahlDebiKredi, r, c )
c += 1
self._betrag.setPlaceholderText( "Betrag" )
self._betrag.setToolTip( "Ursprünglicher offener Betrag. '-' = Debit, '+' = Kredit" )
self._betrag.setFixedWidth( 80 )
l.addWidget( self._betrag, r, c )
c += 1
self._betragBeglichen.setPlaceholderText( "bezahlt" )
self._betragBeglichen.setToolTip( "Bereits bezahlter Betrag" )
self._betragBeglichen.setFixedWidth( 80 )
l.addWidget( self._betragBeglichen, r, c )
c += 1
self._letzteBuchungAm.setPlaceholderText( "letzte Buchg" )
self._letzteBuchungAm.setToolTip( "Datum der letzten (Teil-)Buchung" )
self._letzteBuchungAm.setMaximumWidth( 90 )
l.addWidget( self._letzteBuchungAm, r, c )
c += 1
self._bemerkung.setToolTip( "Bemerkung - z.B. Dokumentation von Teilzahlungen" )
self._bemerkung.setPlaceholderText( "Bemerkung" )
self._bemerkung.setMaximumHeight( 60 )
l.addWidget( self._bemerkung, r, c )
def _dataToGui( self ) -> None:
x = self._offenerPosten
self._erfasstAm.setDateFromIsoString( x.erfasst_am )
self._debiKredi.setText( x.debi_kredi )
self._betrag.setFloatValue( x.betrag )
self._betragBeglichen.setFloatValue( x.betrag_beglichen )
if x.letzte_buchung_am:
self._letzteBuchungAm.setDateFromIsoString( x.letzte_buchung_am )
self._bemerkung.setPlainText( x.bemerkung )
def guiToData( self ) -> None:
x = self._offenerPosten
x.erfasst_am = self._erfasstAm.getDate()
x.debi_kredi = self._debiKredi.text()
x.betrag = self._betrag.getFloatValue()
x.betrag_beglichen = self._betragBeglichen.getFloatValue()
x.letzte_buchung_am = self._letzteBuchungAm.getDate()
x.bemerkung = self._bemerkung.toPlainText()
def getOposCopyWithChanges( self ) -> XOffenerPosten:
"""
liefert eine Kopie des in ARbeit befindlichen XOffenerPosten-Objekts.
Die in der GUI vorgenommenen Änderungen sind darin enthalten.
Die Änderungen sind NICHT im Original-OPOS enthalten!
Das Einfügen der Änderungen in das Original-OPOS passiert durch Aufruf von guiToData().
:return: eine Kopie des Original-OPOS mit Änderungen
"""
xcopy = copy.copy( self._offenerPosten )
xcopy.erfasst_am = self._erfasstAm.getDate()
xcopy.debi_kredi = self._debiKredi.text()
xcopy.betrag = self._betrag.getFloatValue()
xcopy.betrag_beglichen = self._betragBeglichen.getFloatValue()
xcopy.letzte_buchung_am = self._letzteBuchungAm.getDate()
xcopy.bemerkung = self._bemerkung.toPlainText()
return xcopy
def _onDebiKrediAuswahl_Firma( self ):
self.debiKrediAuswahlFirmaPressed.emit()
def _onDebiKrediAuswahl_Vw( self ):
self.debiKrediAuswahlVwPressed.emit()
def setOffenerPosten( self, x:XOffenerPosten ):
self._offenerPosten = x
if x.erfasst_am > "":
self._erfasstAm.setDateFromIsoString( x.erfasst_am )
self._debiKredi.setText( x.debi_kredi )
self._betrag.setFloatValue( x.betrag )
self._betragBeglichen.setFloatValue( x.betrag_beglichen )
if x.letzte_buchung_am > "":
self._letzteBuchungAm.setDateFromIsoString( x.letzte_buchung_am )
self._bemerkung.setPlainText( x.bemerkung )
def getOffenerPosten( self ) -> XOffenerPosten:
x = self._offenerPosten
if x is None: return XOffenerPosten()
x.erfasst_am = self._erfasstAm.getDate()
x.debi_kredi = self._debiKredi.text()
x.betrag = self._betrag.getFloatValue()
x.betrag_beglichen = self._betragBeglichen.getFloatValue()
x.letzte_buchung_am = self._letzteBuchungAm.getDate()
x.bemerkung = self._bemerkung.toPlainText()
return x
def setDebiKredi( self, debikredi:str ):
self._debiKredi.setText( debikredi )
class GeschaeftsreiseEditView(QWidget):
def __init__(self,
mobjIdList: List[str] = None,
x: XGeschaeftsreise = None,
parent=None):
QWidget.__init__(self, parent)
self._xgeschaeftsreise = x
self._layout = QFormLayout()
self.setLayout(self._layout)
self._cboMobjId = QComboBox()
self._sdVon = SmartDateEdit()
self._sdBis = SmartDateEdit()
self._beZiel = BaseEdit()
self._meZweck = MultiLineEdit()
self._ieKm = IntEdit()
self._iePersonen = IntEdit()
self._beUebernachtung = BaseEdit()
self._feUebernachtKosten = FloatEdit()
# self._btnSave = QPushButton( "Speichern" )
# self._btnSaveClose = QPushButton( "Speichern und Schließen" )
# self._btnCancel = QPushButton( "Abbrechen" )
self._createGui()
if mobjIdList:
self.setMietobjekte(mobjIdList)
if x:
self.setData(x)
def _createGui(self):
"""
:return:
"""
l = self._layout
self._cboMobjId.setMaximumWidth(100)
l.addRow("Mietobjekt: ", self._cboMobjId)
self._sdVon.setMaximumWidth(100)
l.addRow("Beginn: ", self._sdVon)
self._sdBis.setMaximumWidth(100)
l.addRow("Ende: ", self._sdBis)
l.addRow("Ziel: ", self._beZiel)
self._meZweck.setMaximumHeight(80)
l.addRow("Zweck: ", self._meZweck)
l.addRow("Übernachtung: ", self._beUebernachtung)
self._feUebernachtKosten.setMaximumWidth(55)
l.addRow("Übernacht.-Kosten: ", self._feUebernachtKosten)
self._ieKm.setMaximumWidth(55)
l.addRow("Gefahrene Kilometer: ", self._ieKm)
self._iePersonen.setMaximumWidth(55)
l.addRow("Anz.Personen: ", self._iePersonen)
dummy = QWidget()
dummy.setFixedHeight(20)
l.addRow("", dummy)
# boxl = QHBoxLayout()
# boxl.addWidget( self._btnSave )
# boxl.addWidget( self._btnSaveClose )
# boxl.addWidget( self._btnCancel )
# l.addRow( boxl )
def _setFieldsFromData(self):
"""
:return:
"""
x = self._xgeschaeftsreise
self._cboMobjId.setCurrentText(x.mobj_id)
self._sdVon.setDateFromIsoString(x.von)
self._sdBis.setDateFromIsoString(x.bis)
self._beZiel.setText(x.ziel)
self._meZweck.setText(x.zweck)
self._ieKm.setIntValue(x.km)
self._iePersonen.setIntValue(x.personen)
self._beUebernachtung.setText(x.uebernachtung)
self._feUebernachtKosten.setFloatValue(x.uebernacht_kosten)
def _setDataFromFields(self, x: XGeschaeftsreise):
x.mobj_id = self._cboMobjId.currentText()
x.von = self._sdVon.getDate()
x.bis = self._sdBis.getDate()
x.ziel = self._beZiel.text()
x.zweck = self._meZweck.toPlainText()
x.km = self._ieKm.getIntValue()
x.personen = self._iePersonen.getIntValue()
x.uebernachtung = self._beUebernachtung.text()
x.uebernacht_kosten = self._feUebernachtKosten.getFloatValue()
def setMietobjekte(self, mobj_idList: List[str]):
"""
Versorgt die ComboBox mit den möglichen Werten (Mietobjekten)
Diese Methode muss VOR setData() aufgerufen werden.
:param mobj_idList:
:return:
"""
self._cboMobjId.addItems(mobj_idList)
def getDataCopyWithChanges(self) -> XGeschaeftsreise:
x = copy.copy(self._xgeschaeftsreise)
self._setDataFromFields(x)
return x
def applyChanges(self) -> XGeschaeftsreise:
self._setDataFromFields(self._xgeschaeftsreise)
return self._xgeschaeftsreise
def setData(self, x: XGeschaeftsreise) -> None:
self._xgeschaeftsreise = x
self._setFieldsFromData()
class MietverhaeltnisView(QWidget, ModifyInfo):
save = Signal()
dataChanged = Signal()
nextMv = Signal()
prevMv = Signal()
def __init__(self,
mietverhaeltnis: XMietverhaeltnis = None,
withSaveButton: bool = False,
enableBrowsing=False,
parent=None):
QWidget.__init__(self, parent)
ModifyInfo.__init__(self)
self._mietverhaeltnis: XMietverhaeltnis = None
self._withSaveButton = withSaveButton
self._enableBrowsing = enableBrowsing # ob die Browse-Buttons angezeigt werden
self._layout = QGridLayout()
self._btnSave = QPushButton()
self._btnVor = QPushButton()
self._btnRueck = QPushButton()
self._sdBeginnMietverh = SmartDateEdit()
self._sdEndeMietverh = SmartDateEdit()
self._edMieterName_1 = BaseEdit()
self._edMieterVorname_1 = BaseEdit()
self._edMieterName_2 = BaseEdit()
self._edMieterVorname_2 = BaseEdit()
self._edMieterTelefon = BaseEdit()
self._edMieterMobil = BaseEdit()
self._edMieterMailto = BaseEdit()
self._edAnzPers = IntEdit()
self._edNettomiete = FloatEdit()
self._edNkv = FloatEdit()
self._edKaution = IntEdit()
self._sdKautionBezahltAm = SmartDateEdit()
self._txtBemerkung1 = MultiLineEdit()
self._txtBemerkung2 = MultiLineEdit()
self._createGui()
if mietverhaeltnis:
self.setMietverhaeltnisData(mietverhaeltnis)
#self.connectWidgetsToChangeSlot( self.onChange )
self.connectWidgetsToChangeSlot(self.onChange, self.onResetChangeFlag)
def onChange(self, newcontent: str = None):
if not self._btnSave.isEnabled():
self.setSaveButtonEnabled()
self.dataChanged.emit()
def onResetChangeFlag(self):
self.setSaveButtonEnabled(False)
def setSaveButtonEnabled(self, enabled: bool = True):
self._btnSave.setEnabled(enabled)
def _createGui(self):
hbox = QHBoxLayout()
if self._withSaveButton:
self._createSaveButton(hbox)
if self._enableBrowsing:
self._createVorRueckButtons(hbox)
self._layout.addLayout(hbox, 0, 0, alignment=Qt.AlignLeft)
self._addHorizontalLine(1)
self._createFelder(2)
self.setLayout(self._layout)
def _createSaveButton(self, hbox):
btn = self._btnSave
btn.clicked.connect(self.save.emit)
btn.setFlat(True)
btn.setEnabled(False)
btn.setToolTip("Änderungen am Mietverhältnis speichern")
icon = ImageFactory.inst().getSaveIcon()
#icon = QIcon( "./images/save_30.png" )
btn.setIcon(icon)
size = QSize(32, 32)
btn.setFixedSize(size)
iconsize = QSize(30, 30)
btn.setIconSize(iconsize)
hbox.addWidget(btn)
def _createVorRueckButtons(self, hbox):
self._prepareButton(self._btnRueck,
ImageFactory.inst().getPrevIcon(),
"Zum vorigen Mietverhältnis blättern", self.prevMv)
hbox.addWidget(self._btnRueck)
self._prepareButton(self._btnVor,
ImageFactory.inst().getNextIcon(),
"Zum nächsten Mietverhältnis blättern",
self.nextMv)
hbox.addWidget(self._btnVor)
def _prepareButton(self, btn: QPushButton, icon: QIcon, tooltip: str,
signal: Signal):
btn.setFlat(True)
btn.setEnabled(True)
btn.setToolTip(tooltip)
btn.setIcon(icon)
size = QSize(32, 32)
btn.setFixedSize(size)
iconsize = QSize(30, 30)
btn.setIconSize(iconsize)
btn.clicked.connect(signal.emit)
def _addHorizontalLine(self, r: int):
hline = HLine()
self._layout.addWidget(hline, r, 0, 1, 2)
return r + 1
def _createFelder(self, r):
c = 0
l = self._layout
lbl = QLabel("Beginn: ")
l.addWidget(lbl, r, c)
c += 1
self._sdBeginnMietverh.setMaximumWidth(100)
l.addWidget(self._sdBeginnMietverh, r, c)
c = 0
r += 1
l.addWidget(BaseLabel("Ende: "), r, c)
c += 1
self._sdEndeMietverh.setMaximumWidth(100)
l.addWidget(self._sdEndeMietverh, r, c)
c = 0
r += 1
lbl = BaseLabel("Name / Vorname 1. Mieter: ")
l.addWidget(lbl, r, c)
c += 1
hbox = QHBoxLayout()
hbox.addWidget(self._edMieterName_1)
hbox.addWidget(self._edMieterVorname_1)
l.addLayout(hbox, r, c)
c = 0
r += 1
lbl = BaseLabel("Name / Vorname 2. Mieter: ")
l.addWidget(lbl, r, c)
c += 1
hbox = QHBoxLayout()
hbox.addWidget(self._edMieterName_2)
hbox.addWidget(self._edMieterVorname_2)
l.addLayout(hbox, r, c)
c = 0
r += 1
l.addWidget(BaseLabel("Telefon: "), r, c)
c += 1
l.addWidget(self._edMieterTelefon, r, c)
c = 0
r += 1
l.addWidget(BaseLabel("Mobil: "), r, c)
c += 1
l.addWidget(self._edMieterMobil, r, c)
c = 0
r += 1
l.addWidget(BaseLabel("Mailadresse: "), r, c)
c += 1
l.addWidget(self._edMieterMailto, r, c)
c = 0
r += 1
l.addWidget(BaseLabel("Anzahl Personen i.d. Whg: "), r, c)
c += 1
self._edAnzPers.setMaximumWidth(20)
l.addWidget(self._edAnzPers, r, c)
c = 0
r += 1
l.addWidget(BaseLabel("Nettomiete / NKV: "), r, c)
c += 1
self._edNettomiete.setMaximumWidth(100)
#self._edNettomiete.setEnabled( False )
self._edNkv.setMaximumWidth(100)
#self._edNkv.setEnabled( False )
hbox = QHBoxLayout()
hbox.addWidget(self._edNettomiete)
hbox.addWidget(self._edNkv)
hbox.addWidget(
BaseLabel(
" Änderungen der Miete und NKV über Dialog 'Sollmiete'"))
l.addLayout(hbox, r, c, alignment=Qt.AlignLeft)
c = 0
r += 1
l.addWidget(BaseLabel("Kaution: "), r, c)
c += 1
self._edKaution.setMaximumWidth(100)
l.addWidget(self._edKaution, r, c)
c = 0
r += 1
l.addWidget(BaseLabel("Kaution bezahlt am: "), r, c)
c += 1
self._sdKautionBezahltAm.setMaximumWidth(100)
l.addWidget(self._sdKautionBezahltAm, r, c)
c = 0
r += 1
l.addWidget(BaseLabel(""), r, c)
r += 1
l.addWidget(BaseLabel("Bemerkungen: "), r, c)
c += 1
hbox = QHBoxLayout()
hbox.addWidget(self._txtBemerkung1)
hbox.addWidget(self._txtBemerkung2)
l.addLayout(hbox, r, c)
# cols = self._layout.columnCount()
# print( cols, " columns" )
def setNettoUndNkvEnabled(self, enabled: bool = True):
self._edNettomiete.setEnabled(enabled)
self._edNkv.setEnabled(enabled)
def _guiToData(self, x: XMietverhaeltnis):
"""
Überträgt die Änderungen, die der User im GUI gemacht hat, in das
übergebene XMietverhaeltnis-Objekt
:param x: XMietverhaeltnis-Objekt, in das die geänderten Daten übertragen werden
:return:
"""
x.von = self._sdBeginnMietverh.getDate()
x.bis = self._sdEndeMietverh.getDate()
x.name = self._edMieterName_1.text()
x.vorname = self._edMieterVorname_1.text()
x.name2 = self._edMieterName_2.text()
x.vorname2 = self._edMieterVorname_2.text()
x.telefon = self._edMieterTelefon.text()
x.mobil = self._edMieterMobil.text()
x.mailto = self._edMieterMailto.text()
x.anzahl_pers = self._edAnzPers.getIntValue()
x.nettomiete = self._edNettomiete.getFloatValue()
x.nkv = self._edNkv.getFloatValue()
x.kaution = self._edKaution.getIntValue()
x.kaution_bezahlt_am = self._sdKautionBezahltAm.getDate()
x.bemerkung1 = self._txtBemerkung1.toPlainText()
x.bemerkung2 = self._txtBemerkung2.toPlainText()
def getMietverhaeltnisCopyWithChanges(self) -> XMietverhaeltnis:
"""
gibt eine Kopie der Mietverhaeltnis-Schnittstellendaten mit Änderungen zurück.
Diese Kopie kann für Validierungszwecke verwendet werden.
:return: Kopie von XMietverhaeltnis
"""
mvcopy = copy.copy(self._mietverhaeltnis)
self._guiToData(mvcopy)
return mvcopy
def applyChanges(self):
"""
überträgt die Änderungen, die der User im GUI gemacht hat, in das
originale XMietverhaeltnis-Objekt.
"""
if self.isChanged():
self._guiToData(self._mietverhaeltnis)
def setMietverhaeltnisData(self, mv: XMietverhaeltnis):
"""
Daten, die im GUI angezeigt und geändert werden können.
:param mv:
:return:
"""
self._mietverhaeltnis = mv
if mv.von:
self._sdBeginnMietverh.setDateFromIsoString(mv.von)
if mv.bis:
self._sdEndeMietverh.setDateFromIsoString(mv.bis)
self._edMieterName_1.setText(mv.name)
self._edMieterVorname_1.setText(mv.vorname)
self._edMieterName_2.setText(mv.name2)
self._edMieterVorname_2.setText(mv.vorname2)
self._edMieterTelefon.setText(mv.telefon)
self._edMieterMobil.setText(mv.mobil)
self._edMieterMailto.setText(mv.mailto)
self._edAnzPers.setIntValue(mv.anzahl_pers)
self._edNettomiete.setFloatValue(mv.nettomiete)
self._edNkv.setFloatValue(mv.nkv)
if mv.kaution:
self._edKaution.setIntValue(mv.kaution)
if mv.kaution_bezahlt_am:
self._sdKautionBezahltAm.setDateFromIsoString(
mv.kaution_bezahlt_am)
self._txtBemerkung1.setText(mv.bemerkung1)
self._txtBemerkung2.setText(mv.bemerkung2)
self.resetChangeFlag()
def clear(self):
self._sdBeginnMietverh.clear()
self._sdEndeMietverh.clear()
self._edMieterName_1.clear()
self._edMieterVorname_1.clear()
self._edMieterName_2.clear()
self._edMieterVorname_2.clear()
self._edMieterTelefon.clear()
self._edMieterMobil.clear()
self._edMieterMailto.clear()
self._edAnzPers.clear()
self._edNettomiete.clear()
self._edNkv.clear()
self._edKaution.clear()
self._sdKautionBezahltAm.clear()
self._txtBemerkung1.clear()
self._txtBemerkung2.clear()
class GeplantEditView( QWidget ):
"""
Eine View, die zur Anlage und ÄNderung einer Planung dient.
Dazu muss sie in einen Dialog eingebettet werden (wg. der OK- und Cancel-Buttons).
"""
masterobjektChanged = Signal( str )
createHandwerker = Signal()
def __init__( self, masterList:List[str]=None, firmenlist:List[str]=None, x:XGeplant=None, parent=None ):
QWidget.__init__( self, parent )
self._xgeplant = x
self._layout = BaseGridLayout()
self.setLayout( self._layout )
self._cboMasterObjekt = QComboBox()
self._cboMasterObjekt.currentIndexChanged.connect( lambda x: self.masterobjektChanged.emit( self._cboMasterObjekt.currentText() ) )
self._cboMobjId = QComboBox()
self._txtLeistung = MultiLineEdit()
self._cboFirma = QComboBox()
self._btnNewFirma = QPushButton()
self._btnNewFirma.clicked.connect( self.createHandwerker.emit )
self._feKosten = FloatEdit()
self._cbKostenvoranschlag = QCheckBox()
self._cboJahr = QComboBox()
self._cboMonat = QComboBox()
self._cboMonat.addItems( datehelper.monthList )
self._cbBeauftragt = QCheckBox()
self._sdErledigtAm = SmartDateEdit()
self._txtBemerkung = MultiLineEdit()
self._provideJahre()
if masterList:
self.setMasterobjekte( masterList )
if firmenlist:
self.setFirmen( firmenlist )
if x:
self.setData( x )
self._createGui()
def _createGui( self ):
"""
:return:
"""
l = self._layout
r = c = 0
self._cboMasterObjekt.setMaximumWidth( 170 )
l.addPair( "Masterobjekt: ", self._cboMasterObjekt, r, c, 1, 5 )
r, c = r+1, 0
self._cboMobjId.setMaximumWidth( 170 )
l.addPair( "Mietobjekt (optional): ", self._cboMobjId, r, c, 1, 5 )
r += 1
self._txtLeistung.setMaximumHeight( 50 )
l.addPair( "Leistung: ", self._txtLeistung, r, c, 1, 5 )
r += 1
l.addPair( "Firma: ", self._cboFirma, r, c, 1, 4 )
c = 5
self._btnNewFirma.setMaximumSize( QSize( 30, 30 ) )
self._btnNewFirma.setIcon( QIcon( ICON_DIR + "add_512x512.png" ) )
self._btnNewFirma.setToolTip( "Neue Firma erfassen" )
l.addWidget( self._btnNewFirma, r, c )
r, c = r+1, 0
self._feKosten.setMaximumWidth( 90 )
l.addPair( "Kosten: ", self._feKosten, r, c )
c += 2
l.addPair("Kostenvoranschlag: ", self._cbKostenvoranschlag, r, c )
r, c = r+1, 0
self._cboJahr.setMaximumWidth( 90 )
l.addPair("Geplant: ", self._cboJahr, r, c )
c += 2
l.addWidget( self._cboMonat, r, c )
r, c = r+1, 0
l.addPair( "Beauftragt: ", self._cbBeauftragt, r, c )
r, c = r + 1, 0
self._sdErledigtAm.setMaximumWidth( 90 )
l.addPair( "Erledigt am: ", self._sdErledigtAm, r, c )
r, c = r+1, 0
self._txtBemerkung.setMaximumHeight( 50 )
self._txtBemerkung.setPlaceholderText( "Bemerkung" )
l.addWidget( self._txtBemerkung, r, c, 1, 6 )
r, c = r+1, 0
dummy = QWidget()
l.addWidget( dummy, r, c )
def _createGui_( self ):
"""
:return:
"""
l = self._layout
r = c = 0
self._cboMasterObjekt.setMaximumWidth( 170 )
l.addPair( "Masterobjekt: ", self._cboMasterObjekt, r, c, 1, 5 )
r, c = r+1, 0
self._cboMobjId.setMaximumWidth( 170 )
l.addPair( "Mietobjekt (optional): ", self._cboMobjId, r, c, 1, 5 )
r += 1
self._txtLeistung.setMaximumHeight( 50 )
l.addPair( "Leistung: ", self._txtLeistung, r, c, 1, 4 )
r += 1
l.addPair( "Firma: ", self._cboFirma, r, c, 1, 4 )
c += 1
self._btnNewFirma.setMaximumSize( QSize( 30, 30 ) )
self._btnNewFirma.setIcon( QIcon( ICON_DIR + "save.png" ) )
self._btnNewFirma.setToolTip( "Neue Firma erfassen" )
#l.addWidget( self._btnNewFirma, r, c )
r, c = r+1, 0
self._feKosten.setMaximumWidth( 90 )
l.addPair( "Kosten: ", self._feKosten, r, c )
c += 2
l.addPair("Kostenvoranschlag: ", self._cbKostenvoranschlag, r, c )
r, c = r+1, 0
self._cboJahr.setMaximumWidth( 90 )
l.addPair("Geplant: ", self._cboJahr, r, c )
c += 2
l.addWidget( self._cboMonat, r, c )
r, c = r+1, 0
l.addPair( "Beauftragt: ", self._cbBeauftragt, r, c )
r, c = r + 1, 0
self._sdErledigtAm.setMaximumWidth( 90 )
l.addPair( "Erledigt am: ", self._sdErledigtAm, r, c )
r, c = r+1, 0
self._txtBemerkung.setMaximumHeight( 50 )
self._txtBemerkung.setPlaceholderText( "Bemerkung" )
l.addWidget( self._txtBemerkung, r, c, 1, 5 )
r, c = r+1, 0
dummy = QWidget()
l.addWidget( dummy, r, c )
def _provideJahre( self ):
y = datehelper.getCurrentYear()
yearlist = []
for y_ in range( y-2, y+6 ):
yearlist.append( str(y_) )
self._cboJahr.addItems( yearlist )
self._cboJahr.setCurrentText( str(y) )
def _setFieldsFromData( self ):
"""
:return:
"""
x = self._xgeplant
self._cboMobjId.setCurrentText( x.mobj_id )
self._txtLeistung.setText( x.leistung )
self._cboFirma.setCurrentText( x.firma )
self._feKosten.setFloatValue( x.kosten )
self._cbKostenvoranschlag.setChecked( True if x.kostenvoranschlag > 0 else False )
self._cboJahr.setCurrentText( str( x.jahr ) )
monat = datehelper.monthList[x.monat-1]
self._cboMonat.setCurrentText( monat )
self._sdErledigtAm.setDateFromIsoString( x.erledigtDatum )
self._txtBemerkung.setText( x.bemerkung )
def _setDataFromFields( self, x:XGeplant ):
x.mobj_id = self._cboMobjId.currentText()
x.leistung = self._txtLeistung.text()
x.firma = self._cboFirma.currentText()
x.kosten = self._feKosten.getFloatValue()
x.kostenvoranschlag = 1 if self._cbKostenvoranschlag.isChecked() else 0
x.jahr = int( self._cboJahr.currentText() )
monat = self._cboMonat.getCurrentText()
monIdx = datehelper.monthList.index( monat ) + 1
x.monat = monIdx
x.erledigtDatum = self._sdErledigtAm.getDate()
x.bemerkung = self._txtBemerkung.toPlainText()
def setMasterobjekte( self, masterlist:List[str] ):
self._cboMasterObjekt.addItems( masterlist )
def setMietobjekte( self, mobj_idList:List[str] ):
"""
Versorgt die ComboBox mit den möglichen Werten (Mietobjekten)
Diese Methode muss VOR setData() aufgerufen werden.
:param mobj_idList:
:return:
"""
self._cboMobjId.addItems( mobj_idList )
def clearMietobjekte( self ):
self._cboMobjId.clear()
def setFirmen( self, firmenlist:List[str] ):
self._cboFirma.addItems( firmenlist )
def getDataCopyWithChanges( self ) -> XGeplant:
x = copy.copy( self._xgeschaeftsreise )
self._setDataFromFields( x )
return x
def applyChanges( self ) -> XGeplant:
self._setDataFromFields( self._xgeschaeftsreise )
return self._xgeplant
def setData( self, x:XGeplant ) -> None:
self._xgeplant = x
self._setFieldsFromData()