def setLocked(self, bool=True):
if self.reallyLocked and bool == False:
self.ui.leftPanel.setCurrentIndex(0)
self.ui.button_keep_unlocked.setChecked(False)
speicher = Speicher()
user = speicher.get_current_user()
role = user['role']
if role == 'admin':
self.ui.menubar.show()
self.reallyLocked = False
self.showStartpage()
if bool == False:
self.unlocked = time.time()
if self.currentWidget == 'codeentry':
if self.showAfterUnlock in self.WIDGETS.keys():
self.showWidget(self.showAfterUnlock)
self.showAfterUnlock = None
else:
self.showStartpage()
self.ui.lock_status.setCurrentIndex(1)
self.unlockTimerTriggered()
self.ui.button_keep_unlocked.setChecked(False)
self.unlock_timer.timeout.connect(self.unlockTimerTriggered)
self.ui.button_lock.clicked.connect(self.setLocked)
self.ui.button_keep_unlocked.clicked.connect(self.keepUnlocked)
self.unlock_timer.start(100)
else:
self.unlocked = False
self.showAfterUnlock = None
self.ui.lock_status.setCurrentIndex(0)
self.unlock_timer.stop()
def ok(self):
kst = str(self.ui.combo_biokontrollstelle.currentText())
if '(' in kst:
kst = kst[:kst.find('(')].strip()
self.kunde.setOekoKontrollstelle(kst)
anlieferdatum = self.ui.dateEdit.date().toPyDate()
data = {
'kunde': self.kunde.ID(),
'adresse': self.kunde.getAdresse(),
'menge': str(self.ui.input_menge.text()),
'kontrollstelle': kst,
'obstart': {},
'anlieferdatum': anlieferdatum.isoformat(),
}
if not data['menge']:
QtWidgets.QMessageBox.warning(
self,
u'Fehler',
u'Obst-Menge fehlt!',
buttons=QtWidgets.QMessageBox.Ok,
defaultButton=QtWidgets.QMessageBox.Ok)
return
for key in ['apfel', 'birne', 'quitte']:
if getattr(self.ui, 'button_%s' % key).isChecked():
data['obstart'][key] = True
s = Speicher()
s.speichereBioLieferschein(data)
pdffile = BioLieferschein(data)
c = cups.Connection()
c.printFile(c.getDefault(), pdffile, 'Bio-Lieferschein %s' % pdffile,
PRINTER_OPTIONS)
self.close()
def receive_status_backend(belegliste):
if type(belegliste) != type([]):
belegliste = [
belegliste,
]
import requests
try:
rq = requests.get(
'http://sms.mosterei-wurst.de/read.py',
params={'vorgang': [vorgang.ID for vorgang in belegliste]},
timeout=1)
data = rq.json()
s = Speicher()
for vorgang in belegliste:
if vorgang.ID in data.keys():
anrufe = s.getAnrufe(vorgang)
for ts, status in data[vorgang.ID]:
found = False
for a in anrufe:
if a['ergebnis'] == 'sms-' + status:
found = True
if not found:
s.speichereAnruf(
vorgang, 'sms-' + status, 'SMS-Status von ' +
datetime.datetime.fromtimestamp(ts).isoformat())
except:
pass
def __init__(self, mainwindow, newpin = False):
QtWidgets.QWidget.__init__(self)
self.mainwindow = mainwindow
self.__mode = 0
if newpin:
self.__mode = 1
try:
self.ui = uic.loadUi('ressource/ui/widget_codeentry.ui', self)
except:
print ('Kann UI-Datei nicht laden!')
sys.exit(1)
self.speicher = Speicher()
self.errorcounter = 0
self.wakeup_timer = QtCore.QTimer(self)
self.ui.progress_lock.hide()
if self.__mode < 2:
self.ui.button_ok.hide()
self.ui.label_kopfzeile.setText('Gesperrt: Bitte Code eingeben')
if self.__mode == 1:
self.ui.label_kopfzeile.setText(u'Bisheriger Code')
self.connectSlots()
def transitbuchung(self, betrag, beschreibung):
tse_trxnum = None
tse_time_start = None
try:
tse = TSE()
response = tse.transaction_start('', '')
tse_trxnum = response.transactionNumber
tse_time_start = response.logTime
except TSEException:
pass
v = Vorgang()
s = Speicher()
v.newItem(1,
beschreibung=beschreibung,
einzelpreis=betrag,
steuersatz=0.0)
v.setPayed(True)
v.setStatus('transit')
s.speichereZahlung(v, 'transit', betrag)
v = s.ladeVorgang(v.ID)
kb = Kassenbeleg(v,
'transit',
tse_trxnum=tse_trxnum,
tse_time_start=tse_time_start)
self.get_kassenstand()
self.calculate()
def __init__(self, kunde, neu=True, edit=False):
# Konstruktor der Superklasse aufrufen
QtWidgets.QDialog.__init__(self,
flags=QtCore.Qt.Window
| QtCore.Qt.FramelessWindowHint)
try:
self.ui = uic.loadUi('ressource/ui/kundenauswahl.ui', self)
except:
print('Kann UI-Datei nicht laden!')
sys.exit(1)
self.showFullScreen()
self.speicher = Speicher()
self.kunde = kunde
if not self.kunde:
self.kunde = Kunde()
if not neu:
self.ui.button_neu.setStyleSheet('display:none;')
self.ui.button_neu.setEnabled(False)
# Soll am Ende immer ein Fenster zum Bearbetien der Kundendaten ausgerufen werden?
self.edit = edit
self.shift = False
self.capslock = False
self.ui.input_text.setText(u'%s' % self.kunde.getErsteTelefon())
self.ui.input_text.selectAll()
self.updateVorschlaege()
self.updateButtonLabels()
self.connectSlots()
def updateAuftraege(self, foobar=None):
self.year = str(self.ui.combo_year.currentText()).strip()
if hasattr(self, 'speicher'):
del self.speicher
self.speicher = Speicher(self.year)
self.ui.textBrowser.clear()
self.__auftragsliste = []
if self.filter_kunde:
self.__auftragsliste = self.speicher.listAuftraegeByKunde(
self.filter_kunde)
elif not self.__erledigte:
self.__auftragsliste = self.speicher.listOffeneAuftraege()
if self.__showall and self.__erledigte and not self.filter_kunde:
self.__showall = False
if self.__list_sorting == 'DateDesc':
self.__auftragsliste = self.speicher.listAuftraegeByDateDesc()
elif self.__list_sorting == 'DateAsc':
self.__auftragsliste = self.speicher.listAuftraegeByDateAsc()
elif self.__list_sorting == 'Name':
self.__auftragsliste = self.speicher.listAuftraegeByName()
else:
self.__auftragsliste = self.speicher.listAuftraege()
if self.filter_kunde and not self.__auftragsliste:
label = QtWidgets.QLabel("Keine Ergebnisse")
self.ui.listWidget_2.clear()
item = QtWidgets.QListWidgetItem()
item.setSizeHint(
QtCore.QSize(self.ui.listWidget_2.size().width() - 40, 100))
self.ui.listWidget_2.addItem(item)
self.ui.listWidget_2.setItemWidget(item, label)
elif not self.__auftragsliste and self.__erledigte:
button_showall = QtWidgets.QPushButton("Alle Aufträge anzeigen")
button_showall.clicked.connect(self.showall)
self.ui.listWidget_2.clear()
item = QtWidgets.QListWidgetItem()
item.setSizeHint(
QtCore.QSize(self.ui.listWidget_2.size().width() - 40, 100))
self.ui.listWidget_2.addItem(item)
self.ui.listWidget_2.setItemWidget(item, button_showall)
else:
self.ui.listWidget_2.clear()
for auftrag in self.__auftragsliste:
entry = AuftragWidget(auftrag)
item = QtWidgets.QListWidgetItem()
item.setSizeHint(
QtCore.QSize(self.ui.listWidget_2.size().width() - 40, 68))
self.ui.listWidget_2.addItem(item)
self.ui.listWidget_2.setItemWidget(item, entry)
self.auftragAusgewaehlt()
def __init__(self, mainwindow, extended = False, last10 = False):
QtWidgets.QWidget.__init__(self)
self.mainwindow = mainwindow
self.ui = None
try:
self.ui = uic.loadUi('ressource/ui/widget_history.ui', self.ui)
except:
print ('Kann UI-Datei nicht laden!')
sys.exit(1)
self.year = datetime.date.today().year
self.speicher = Speicher(self.year)
self.__invoicelist_sorting = 'Name'
self.__extended = extended
self.__last10 = last10
self.__showall = False
self.__menu = False
self.filter_kunde = None
self.__aktueller_vorgang = None
self.ui.input_suche.clicked = self.sucheClicked
self.ui.input_suche.installEventFilter(self)
self.ui.listWidget_2.itemClicked.connect(self.listWidgetClick)
self.ui.listWidget_version.currentItemChanged.connect(self.versionAusgewaehlt)
self.ui.button_bearbeiten.clicked.connect(self.vorgangOeffnen)
self.ui.button_beleganzeigen.clicked.connect(self.belegAnzeigen)
self.ui.button_rechnung_storno.clicked.connect(self.rechnungStornieren)
self.ui.button_bezahlt.clicked.connect(self.toggleBezahlt)
self.ui.combo_year.currentIndexChanged.connect(self.updateAlteVorgaenge)
self.ui.combo_sortierung.currentIndexChanged.connect(self.sortingChanged)
self.ui.input_suche.textChanged.connect(self.updateAlteVorgaenge)
self.ui.button_sucheLeeren.clicked.connect(self.clearSuche)
self.ui.button_reload.clicked.connect(self.reload)
self.ui.button_listedrucken.clicked.connect(self.listedrucken)
self.ui.button_extended.clicked.connect(self.extended)
self.ui.button_anrufen.clicked.connect(self.anrufenClicked)
self.ui.button_zurueckstellen.clicked.connect(self.zurueckstellen)
self.ui.button_sammelbeleg.clicked.connect(self.vorgangKassieren)
self.ui.button_sammelbeleg.hide()
self.setupUI()
def import_auftraege():
import json
import os, os.path
from lib.Speicher import Speicher
speicher = Speicher()
assert speicher.is_unlocked(), 'Speicher ist gesperrt!'
for filename in os.listdir(PFAD_JSON):
with open(os.path.join(PFAD_JSON, filename), 'r') as f:
data = json.load(f)
kunde = None
if data['kundennr']:
kunde = speicher.ladeKunde(data['kundennr'])
else:
kunde = Kunde()
telefon = formatPhoneNumber(data['phone'])
typ = 'telefon'
if telefon.startswith('01'):
typ = 'mobile'
kunde.addKontakt(typ, telefon)
kunde['vorname'] = data['fname']
kunde['nachname'] = data['lname']
kunde['strasse'] = data['address']
kunde['plz'] = data['zip']
kunde['ort'] = data['city']
# Finde heraus, ob es diesen Auftrag schon gibt.
versionen = speicher.getAuftragVersionen(data['handle'])
if versionen:
auftrag = speicher.ladeAuftrag(data['handle'])
else:
auftrag = Auftrag(kunde)
mappings = {
'source': 'quelle',
'angeliefert': 'angeliefert',
'handle': 'ID',
'lieferart': 'lieferart',
'gbcount': 'gbcount',
'kennz': 'kennz',
'kartons': 'gebrauchte',
'neue': 'neue',
'sonstiges': 'sonstiges',
'frischsaft': 'frischsaft',
'anmerkungen': 'anmerkungen',
}
for key1, key2 in mappings.items():
if key1 in data:
auftrag.set(key2, data[key1])
if 'date' in data:
auftrag.zeitpunkt = data['date']
if not data['complete']:
auftrag.status = -1
else:
auftrag.status = 0
speicher.speichereAuftrag(auftrag)
os.unlink(os.path.join(PFAD_JSON, filename))
def POST(self):
i = web.input(code="")
session = web.config._session
if i.code:
session.authtoken = random_string(20)
s = Speicher(authtoken=session.authtoken)
if s.check_password(i.code):
session.username = s.get_current_user()['name']
target = session.get('redirect_after_login', None)
if not target:
target = '/'
raise web.seeother(target)
else:
session.errormessage = 'Falscher Code'
raise web.seeother('/auth')
else:
raise web.seeother('/auth')
def __init__(self, mainwindow):
QtWidgets.QWidget.__init__(self)
self.mainwindow = mainwindow
try:
self.ui = uic.loadUi('ressource/ui/widget_startpage.ui', self)
except:
print ('Kann UI-Datei nicht laden!')
sys.exit(1)
self.connectSlots()
lock_icon = QtGui.QIcon('ressource/icons/lock.png')
self.ui.button_sperren.setIcon(lock_icon)
self.__lasterror = None
self.speicher = Speicher()
def check_authenticated(redirect=True):
import web
session = web.config._session
authtoken = session.get('authtoken', None)
if not authtoken:
if redirect:
session.redirect_after_login = web.ctx.path
raise web.seeother('/auth')
else:
return False
s = Speicher(authtoken=authtoken)
username = session.get('username', None)
if s.is_unlocked() and username:
return True
elif redirect:
session.redirect_after_login = web.ctx.path
raise web.seeother('/auth')
return False
class RechnungDialog(QtWidgets.QDialog):
def __init__(self, invoice):
# Konstruktor der Superklasse aufrufen
QtWidgets.QDialog.__init__(self,
flags=QtCore.Qt.Window
| QtCore.Qt.FramelessWindowHint)
try:
self.ui = uic.loadUi('ressource/ui/rechnung.ui', self)
except:
print('Kann UI-Datei nicht laden!')
sys.exit(1)
self.showFullScreen()
self.vorgang = invoice
self.speicher = Speicher()
self.ui.textEdit_adresse.setText(self.vorgang.kunde.getAdresse())
self.ui.button_ok.clicked.connect(self.ok)
self.ui.button_abbrechen.clicked.connect(self.cancel)
self.ui.button_kundendaten.clicked.connect(self.edit_kundendaten)
self.update()
def edit_kundendaten(self):
self.vorgang.kunde = showKundendatenDialog(self.vorgang.kunde)
self.speicher.speichereKunde(self.vorgang.kunde)
self.ui.textEdit_adresse.setText(self.vorgang.kunde.getAdresse())
def cancel(self):
self.reject()
def ok(self):
self.vorgang.setRechnungsadresse(
str(self.ui.textEdit_adresse.toPlainText()))
self.accept()
def update(self):
pass
def eventFilter(self, qobject, qevent):
if qevent.type() == QtCore.QEvent.MouseButtonPress:
qobject.clicked()
return False
def get_kassenstand(self):
self.abschluss['summe_brutto'] = 0.0
self.abschluss['summe_netto'] = 0.0
self.abschluss['summe_mwst'] = 0.0
self.abschluss['summe_bar'] = 0.0
self.abschluss['summe_transit'] = 0.0
self.abschluss['ersterbeleg'] = None
s = Speicher()
letzter_abschluss = s.getLetzterAbschluss()
kassenstand = 0.0
infotext = ''
if letzter_abschluss:
infotext += 'Letzter Abschluss vom %s:\nKassenstand: %s\n\n' % (
letzter_abschluss['timestamp'].isoformat(),
getMoneyValue(letzter_abschluss['kassenstand']))
kassenstand = letzter_abschluss['kassenstand']
self.abschluss[
'ersterbeleg'] = letzter_abschluss['letzterbeleg'] + 1
else:
infotext += 'Keinen vorherigen Abschluss gefunden!\n\n'
belege = s.listKassenbelege(self.abschluss['ersterbeleg'])
for b in belege:
if not self.abschluss['ersterbeleg']:
self.abschluss['ersterbeleg'] = b['id']
kassenstand += b['kassenbewegung']
if b['type'] == 'transit' and b['summen']['summe']['mwst'] == 0:
self.abschluss['summe_transit'] += b['kassenbewegung']
else:
self.abschluss['summe_brutto'] += b['summen']['summe'][
'brutto']
self.abschluss['summe_netto'] += b['summen']['summe']['netto']
self.abschluss['summe_mwst'] += b['summen']['summe']['mwst']
self.abschluss['summe_bar'] += b['kassenbewegung']
self.abschluss['letzterbeleg'] = b['id']
infotext += 'Umsatz brutto: %s\nUmsatz netto: %s\nMwSt: %s\n\nSumme der Barzahlungen: %s\n\nSumme der Transitbuchungen: %s\n' % (
getMoneyValue(self.abschluss['summe_brutto']),
getMoneyValue(self.abschluss['summe_netto']),
getMoneyValue(self.abschluss['summe_mwst']),
getMoneyValue(self.abschluss['summe_bar']),
getMoneyValue(self.abschluss['summe_transit']))
self.__kassenstand_berechnet = kassenstand
self.ui.infotext.setText(infotext)
def __init__(self, mainwindow):
QtWidgets.QWidget.__init__(self)
self.mainwindow = mainwindow
try:
self.ui = uic.loadUi('ressource/ui/widget_abfuellung.ui', self)
except:
print('Kann UI-Datei nicht laden!')
sys.exit(1)
self.speicher = Speicher()
self.pl = Preisliste()
self.rabattStufen = [i[1] for i in self.pl.rabattStufen('5er')]
while self.ui.combo_manuelleLiter.count() > 0:
self.ui.combo_manuelleLiter.removeItem(0)
for liter in self.rabattStufen:
self.ui.combo_manuelleLiter.addItem('%s' % liter)
self.connectSlots()
self.stylesheetInputHighlighted = 'background-color: #faa; font-style: italic; border: 1px solid black;'
self.stylesheetInputRegular = 'border: 1px solid black; background-color: white;'
#for widget in self.ui.stackedWidget.findChildren(QtWidgets.QToolButton):
# widget.setStyleSheet('border: 1px solid black;\nbackground-color: white;')
self.ui.stackedWidget.widget(0).setStyleSheet(
'background-color: #96ff96;')
self.ui.stackedWidget.widget(1).setStyleSheet(
'background-color: #ffffff;')
self.ui.stackedWidget.widget(2).setStyleSheet(
'background-color: #9696ff;')
self.ui.stackedWidget.widget(3).setStyleSheet(
'background-color: #ff9696;')
self.alte_kundenvorgaenge = None
self.liter_alte_abfuellungen = 0
self.rabattstufe_berechnen = True
self.modus = 'speichern'
self.neuerVorgang()
def GET(self, date=None):
check_authenticated()
if not date:
date = datetime.date.today().isoformat()
year = date[:4]
s = Speicher(year=year, authtoken=get_authtoken())
try:
zahlungen = s.listZahlungenTagesjournal(str(date))
except:
raise
return 'Speicher nicht entsperrt!'
data = {}
for z in zahlungen:
if not z['zahlart'] in data.keys():
data[z['zahlart']] = []
data[z['zahlart']].append(z)
output = u'Journal vom %s' % date
zahlart = {'ec': 'EC-Cash', 'bar': 'Barzahlung'}
for key in ['ec', 'bar']:
if key not in data.keys():
continue
anonymous = 0.0
output += u'<br /><h3>%s</h3>\n<table style="width: 100%%"><tr><th>Name</th><th style="width: 10em">Betrag</th></tr>\n' % zahlart[
key]
summe = 0.0
for z in data[key]:
name = z['name']
summe += z['betrag']
if not z['name']:
name = '<i>Anonymer Kunde</i>'
#anonymous += z['betrag']
#continue
output += u'<tr><td>%s</td><td class="right">%.2f €</td></tr>' % (
name, z['betrag'])
if anonymous > 0:
output += u'<tr><td>Anonyme Kunden</td><td class="right">%.2f €</td></tr>' % anonymous
output += u'<tr><td class="right"><b>Summe %s:</b></td><td class="right"><b>%.2f €</b></td></tr></table>' % (
zahlart[key], summe)
return html.page('Journal vom %s' % date, output)
def __init__(self, mainwindow):
QtWidgets.QWidget.__init__(self)
self.mainwindow = mainwindow
self.ui = None
try:
self.ui = uic.loadUi('ressource/ui/widget_auftraege.ui', self.ui)
except:
print('Kann UI-Datei nicht laden!')
sys.exit(1)
self.year = datetime.date.today().year
self.speicher = Speicher(self.year)
self.__list_sorting = 'Name'
self.__erledigte = False
self.__showall = False
self.filter_kunde = None
self.ui.input_suche.clicked = self.sucheClicked
self.ui.input_suche.installEventFilter(self)
self.ui.listWidget_2.itemClicked.connect(self.listWidgetClick)
self.ui.listWidget_2.currentItemChanged.connect(
self.auftragAusgewaehlt)
self.ui.listWidget_version.currentItemChanged.connect(
self.versionAusgewaehlt)
#self.ui.button_bearbeiten.clicked.connect(self.belegOeffnen)
#self.ui.button_belegdrucken.clicked.connect(self.belegDruckenThermo)
self.ui.button_bio.clicked.connect(self.toggleBio)
self.ui.combo_year.currentIndexChanged.connect(self.updateAuftraege)
self.ui.combo_sortierung.currentIndexChanged.connect(
self.sortingChanged)
self.ui.input_suche.textChanged.connect(self.updateAuftraege)
self.ui.button_sucheLeeren.clicked.connect(self.clearSuche)
self.ui.button_reload.clicked.connect(self.reload)
self.ui.button_listedrucken.clicked.connect(self.listedrucken)
self.ui.button_erledigte.clicked.connect(self.extended)
def POST(self):
from lib.BioLieferschein import BioLieferschein
check_authenticated()
s = Speicher(authtoken=get_authtoken())
postdata = web.input(adresse='',
kontrollstelle='',
menge='',
obst=[],
zertifikat={})
data = {
'adresse': postdata['adresse'].replace("\r\n", "\n"),
'menge': postdata['menge'],
'kontrollstelle': postdata['kontrollstelle'],
'obstart': {},
}
for key in postdata['obst']:
data['obstart'][key] = True
s.speichereBioLieferschein(data)
pdffile = BioLieferschein(data)
print(pdffile)
return pdffile
def KassenbelegStornieren(kb):
tse_trxnum = None
tse_time_start = None
try:
tse = TSE()
response = tse.transaction_start('', '')
tse_trxnum = response.transactionNumber
tse_time_start = response.logTime
except TSEException:
pass
s = Speicher()
vorgang = s.ladeVorgang(kb['vorgang'])
storno = Kassenbeleg(vorgang,
'storno',
'storno',
tse_trxnum=tse_trxnum,
tse_time_start=tse_time_start,
storno=kb['id'])
for z in s.getZahlungen(vorgang):
s.loescheZahlung(z['id'])
filename = BelegRechnung(storno)
print("Storno: %s" % filename)
return filename
def update(self):
if self.invoice.getPayed() and self.invoice.getZahlart() == 'ec':
self.ui.label_bezahlung.setPixmap(ec_pixmap)
elif self.invoice.getBanktransfer():
self.ui.label_bezahlung.setPixmap(ueberweisung_pixmap)
elif self.invoice.getPayed():
self.ui.label_bezahlung.setPixmap(bezahlt_pixmap)
elif self.invoice.getPartlyPayed():
self.ui.label_bezahlung.setPixmap(anzahlung_pixmap)
else:
self.ui.label_bezahlung.setPixmap(QtGui.QPixmap())
if self.invoice.isRechnung():
self.ui.label_rechnung.setPixmap(rechnung_pixmap)
else:
self.ui.label_rechnung.setPixmap(QtGui.QPixmap())
if self.invoice.isBio():
self.ui.label_bio.setPixmap(bio_pixmap)
else:
self.ui.label_bio.setPixmap(QtGui.QPixmap())
if not self.invoice.getBanktransfer() and not self.invoice.getPayed():
if self.invoice.getTelefon():
self.ui.label_anruf.setPixmap(telefon_pixmap)
anrufe = Speicher().getAnrufe(self.invoice)
if len(anrufe) > 0:
anruf = anrufe[-1]
if anruf['ergebnis'] == 'erreicht':
self.ui.label_anruf.setPixmap(telefon_ok_pixmap)
elif anruf['ergebnis'] == 'ab':
self.ui.label_anruf.setPixmap(telefon_ab_pixmap)
elif anruf['ergebnis'] == 'nichterreicht':
self.ui.label_anruf.setPixmap(
telefon_nichterreicht_pixmap)
elif anruf['ergebnis'].startswith('sms'):
self.ui.label_anruf.setPixmap(sms_question_pixmap)
if anruf['ergebnis'] == 'sms-delivered':
self.ui.label_anruf.setPixmap(sms_ok_pixmap)
elif anruf['ergebnis'] in ('sms-buffered',
'sms-error'):
self.ui.label_anruf.setPixmap(sms_error_pixmap)
else:
# Hintergrundfarbe, wenn kein Anruf hinterlegt ist (Vor-Ort-Kunde)
if not self.extended:
self.setStyleSheet('background-color: #ffa;')
if self.invoice.getPayed():
self.ui.label_gesamtpreis.setText(u'%.2f €' %
self.invoice.getSumme())
else:
self.ui.label_gesamtpreis.setText(u'%.2f €' %
self.invoice.getZahlbetrag())
def erstelle_abschluss(self):
differenz = self.kassenbestand - self.__kassenstand_berechnet
self.abschluss['kassenstand'] = self.kassenbestand
if differenz:
self.abschluss[
'bemerkung'] = 'Abweichung der Kasse: %s' % getMoneyValue(
differenz)
if QtWidgets.QMessageBox.No == QtWidgets.QMessageBox.warning(
self,
'Abweichung in der Kasse',
'Der Kassenstand entspricht nicht dem errechneten Kassenstand lauf Aufzeichnungen.\nAbweichungsbetrag: %s\nSoll der Abschluss mit Abweichung vorgenommen werden?'
% getMoneyValue(differenz),
buttons=QtWidgets.QMessageBox.Yes
| QtWidgets.QMessageBox.No,
defaultButton=QtWidgets.QMessageBox.No):
return
else:
self.abschluss['bemerkung'] = None
s = Speicher()
s.speichereAbschluss(self.abschluss)
# Drucke Zählprotokoll
self.mainwindow.reset()
def __init__(self, vorgang):
# Konstruktor der Superklasse aufrufen
QtWidgets.QDialog.__init__(self,
flags=QtCore.Qt.Window
| QtCore.Qt.FramelessWindowHint)
try:
self.ui = uic.loadUi('ressource/ui/dialog_anrufen.ui', self)
except:
print('Kann UI-Datei nicht laden!')
sys.exit(1)
self.showFullScreen()
self.speicher = Speicher()
self.vorgang = vorgang
self.ui.button_edit.clicked.connect(self.edit)
self.ui.button_erreicht.clicked.connect(self.erreicht)
self.ui.button_ab.clicked.connect(self.ab)
self.ui.button_nichterreicht.clicked.connect(self.nichterreicht)
self.ui.button_abbrechen.clicked.connect(self.reject)
self.update()
def __init__(self, invoice):
# Konstruktor der Superklasse aufrufen
QtWidgets.QDialog.__init__(self,
flags=QtCore.Qt.Window
| QtCore.Qt.FramelessWindowHint)
try:
self.ui = uic.loadUi('ressource/ui/rechnung.ui', self)
except:
print('Kann UI-Datei nicht laden!')
sys.exit(1)
self.showFullScreen()
self.vorgang = invoice
self.speicher = Speicher()
self.ui.textEdit_adresse.setText(self.vorgang.kunde.getAdresse())
self.ui.button_ok.clicked.connect(self.ok)
self.ui.button_abbrechen.clicked.connect(self.cancel)
self.ui.button_kundendaten.clicked.connect(self.edit_kundendaten)
self.update()
def __init__(self, mainwindow):
QtWidgets.QWidget.__init__(self)
self.speicher = Speicher()
self.mainwindow = mainwindow
self.zahlung_erfolgt = False
self.rechnungdrucken = False
self.rechnungsadresse = None
self.betrag = 0.0
self.gegeben = 0.0
self.numbers = []
try:
self.tse = TSE()
except TSEException:
pass
self.tse_trxnum = None
self.tse_time_start = None
try:
self.ui = uic.loadUi('ressource/ui/widget_kasse.ui', self)
except:
print ('Kann UI-Datei nicht laden!')
sys.exit(1)
self.connectSlots()
def GET(self):
check_authenticated()
s = Speicher(authtoken=get_authtoken())
biokunden = s.getBioKunden()
options = ''
for k in biokunden:
options += u'<option value="%s">%s</option>\n' % (
k['kontrollstelle'], k['adresse'])
content = u'''
<h4>Bio-Anlieferschein erstellen</h4>
<div class="bio_lieferschein_form">
<form method="post" enctype="multipart/form-data" >
<p><label for="biokunden">Bisherige Bio-Kunden:</label> <select name="biokunden" id="biokunden"><option value="0">- Neuer Kunde -</option>
''' + options + u'''
</select></p>
<p><label for="adresse">Adresse:</label> <textarea name="adresse" id="adresse" cols="30" rows="4"></textarea></p>
<p><label for="kontrollstelle">Kontrollstellen-Code:</label> <input type="text" name="kontrollstelle" id="kontrollstelle"></p>
<p><label for="menge">Obst-Menge:</label> <input type="text" name="menge" id="menge"></p>
<p>Obst-Art: <input type="checkbox" name="obst" value="apfel" id="obst_apfel" checked="checked"> <label for="obst_apfel">Bio-Äpfel</label> <input type="checkbox" name="obst" value="birne" id="obst_birne"> <label for="obst_birne" checked="checked">Bio-Birnen</label></p>
<p><label for="zertifikat">Bio-Zertifikat hochladen (PDF):</label> <input type="file" name="zertifikat" id="zertifikat"></p>
<p class="submit"><input type="submit" name="submit" value="Lieferschein erstellen" /></p>
</form>
</div>'''
return html.page(u"Bio-Lieferschein", content)
def BioBeleg(vorgang, filename=None):
if not vorgang:
return False
lieferant = vorgang.getBioLieferant()
kontrollstelle = vorgang.getBioKontrollstelle()
if not kontrollstelle:
return False
pdfdata = PDFBioBeleg(vorgang, lieferant, kontrollstelle)
if not os.path.exists(PFAD):
os.makedirs(PFAD)
if not filename:
nummer = vorgang.getRechnungsnummer()
if not nummer:
nummer = findeNaechsteNummer()
filename = 'BIO-%s.pdf' % nummer
filename = "%s/%s" % (PFAD, filename)
f = open(filename, "wb")
f.write(pdfdata)
f.close()
s = Speicher()
s.speichereVorgang(vorgang)
print('BIO-Beleg saved to %s' % filename)
return filename
def restart(main):
speicher = Speicher()
speicher.lock()
speicher.unmount()
try:
main.printer.terminate()
except:
pass
sys.exit(99)
def umsatzstatistik(year = None):
gesamtsumme = 0.0
anzahl = 0
speicher = Speicher(year)
anonym_umsatz = 0.0
rechnungen_summe = 0.0
speicher.backend.db.execute('SELECT summe, rechnungsnummer, name FROM vorgang WHERE vorgang.currentversion=1')
data = speicher.backend.db.fetchall()
for line in data:
if line['name']:
anzahl += 1
gesamtsumme += line['summe']
else:
anonym_umsatz += line['summe']
if line['rechnungsnummer']:
rechnungen_summe += line['summe']
return (anzahl, gesamtsumme, anonym_umsatz, rechnungen_summe)
def terminate(self, *garbage):
self.reallyLock()
speicher = Speicher()
speicher.lock()
speicher.unmount()
try:
self.printer.terminate()
except:
pass
try:
self.kundendisplay.terminate()
except:
pass
time.sleep(0.1)
self.close()
def tagesstatistik(year = None):
ret = {}
speicher = Speicher(year)
speicher.backend.db.execute('SELECT handle, liter, zeitpunkt, summe, preislisten_id, anzahl, einzelpreis, datum FROM posten CROSS JOIN vorgang ON (posten.vorgang=vorgang.id) WHERE vorgang.currentversion=1')
data = speicher.backend.db.fetchall()
currenthandle = None
for line in data:
datum = line['zeitpunkt'].date().isoformat()
if datum not in ret.keys():
ret[datum] = {'liter': 0,}
id = line['preislisten_id']
if id:
if id in ret[datum].keys():
ret[datum][id][0] += line['anzahl']
ret[datum][id][1] += line['anzahl'] * line['einzelpreis']
else:
ret[datum][id] = [line['anzahl'], line['anzahl'] * line['einzelpreis']]
if line['handle'] != currenthandle:
ret[datum]['liter'] += line['liter']
currenthandle = line['handle']
return ret
