Das deutsche Python-Forum

@ganja: Eine CSV-Datei mit ' als Trennzeichen ist seltsam. Oder versuchst Du die Tupeldarstellungen jetzt mit dem `csv`-Modul zu lesen‽

Ja genau die Tupel lese ich, es geht auch, ist es schon wieder falsch!

Gruß
ganja

@ganja: Naja diese Tupel als Text in Datei ist ”falsch”. Um das sauber und robust zu parsen müsste man `ast.literal_eval()` verwenden und hat dann aber immer noch ein sehr ungewöhnliches, selbstgebasteltes Dateiformat statt etwas verbreitetem wie CSV.

das verstehe ich jetzt nicht, den so wie es im moment ist bekomme ich genau das was ich brauche, ich erstelle die labels, vielleict nicht so wie man es richtig macht, aber es geht, mein problem ist nur das update alle 2 sec von dem ganzen.

Wozu eigentlich überhaupt der Umweg über eine Datei? Wenn ich das auf Seite eins richtig gelesen habe, holst Du Dir die Benutzerdaten aus einer Datenbank (daher dann wohl auch die Tupel?). Übergib doch einfach die Sammlung selber an Deine Gui!

Und wenn der Zwischenschritt unbedingt notwendig ist, dann nutze einfach ein sinnvolles Serialisierungsformat wie eben CSV oder JSON (für letzteres gibt es auch ein Modul in der Standard Lib).

PS: Wie ich schon einmal schrieb ist der Plural von Status auch Status! Nicht Stati oder Statuse oder Statusse... das zu lesen verursacht bei mir Augenschmerzen

Hallo Hyperion,
weil ich mit dem update der Labels nicht zu recht kam, dachte ich ok ich mach dann mehrere files für mysql für rfid_read und ... keine Ahnung.
So mit deinem vorschlag bin ich wieder am anfang, so wie ich es mir gedacht habe und stehe wieder vor dem problem das nicht weiß wie ich meine Labels updaten kann und wo ich sie erstellen soll!
Ich weiß Ihr alle seid Profis, der ein esagt mach so der andere sagt mach so wiederrum sagt der nächste warum so, und ich anfänger bin dann total verwirrt und das was ganz einfach währe bekommt man nicht mehr hin :K .
Ich bin jedem dankbar der mir hilft und ich werde alles was bemengelt wurde, versuchen umzusetzten, aber ich muß es erst verstehen und dann kann ich es umsetzen.
Sorry für statuse, und statis und und, aber mir im moment egal was da steht wenn es tut.
Villeicht kann noch jemand einmal drüber schauen und mir endlich bei dem Labels helfen, ohne das ich nochmal den kompletten ansatz meines codes ändern muss, es kann nicht sein das jedes mal komplett alles falsch ist.
Villeicht ist es nicht möglich so wie ich das vorhabe, das def get_status(self): alle 2 sec in db schaut ob sich etwas geendert hat, und das die Labels alle 2 sec aktualisiert werden, vielleccht muß ich die inhalte erst löschen, ich weiß es nicht.

Danke
Gruß
ganja

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: utf-8 -*-

import Tkinter as tk
import time
import datetime
import MySQLdb

ts = time.time()
sec = int(ts)
dat = time.strftime('%Y-%m-%d')
zeit = time.strftime('%H:%M:%S')
zeit1 = time.strftime('%H')
time1 = ''

class AppGUI:
	def tick(self):
		global zeit
		self.time2 = time.strftime('%H:%M:%S')
		if self.time2 != zeit:
			zeit = self.time2
			self.clock.config(text = self.time2)
		self.clock.after(1000, self.tick)

	def get_status(self):
		status_liste = []
		db=MySQLdb.connect("xxxxxxxxx","xxxx","xxx","xxxx")
		cursor = db.cursor()
		cursor.execute("SELECT idx, user, status, korrektur, name FROM users ORDER BY idx")
		for row in cursor:
			status_liste.append(row)
			#print status_liste
		return status_liste
		cursor.close()
		db.close()

	def __init__(self):
		r = 0
		self.fenster = tk.Tk()
		self.fenster.title('ZEITERFASSUNG')
		self.fenster.geometry("800x600")#+24+10
		self.fenster.configure(background='#AAC4D3')
		
		
		### frame oben time dat
		self.datzeit = tk.Frame(self.fenster, width = 655, height = 30, bg = "yellow", relief = "sunken", border = 2) ##AAC4D3
		self.datzeit.pack(fill='x', pady = "1")#side = 'top'
		#lbl datzeit
		self.labdat = tk.Label(self.datzeit, relief = "groove", width = 10, bg = "white", font = "Verdana 10 bold", text = dat)
		self.labdat.pack(side = "right")
		self.clock = tk.Label(self.datzeit, relief = "groove", width = 10, bg = "white", font = "Verdana 10 bold")
		self.clock.pack(side = "right")#side=LEFT
		
		### frame mitte label and buttons
		self.statf = tk.Frame(self.fenster, width = 655, height = 450, bg = "red", relief = "flat", border = 2)
		self.statf.pack(fill='x', pady = "1")
		
		##### test hier labels erstellen ######
		self.status = self.get_status()
		for status_lesen in self.status:
			status_lesen = list(status_lesen)
			self.name = status_lesen[4]
			self.akt_status = status_lesen[2]
			self.korr = status_lesen[3]
			if self.korr == 'k':
				self.korr = "ZEITKORREKTUR"
				
			if self.akt_status == 'g':
				self.lbn = tk.Label(self.statf, relief="raised", width=15, height=2, bg="#AAC4D3", font = "Verdana 10 bold")
				self.lbn.grid(row=r,column=0)
				self.lbn.config(text = str(self.name))
				self.lbs = tk.Label(self.statf, relief="raised", width=15, height=2, bg="#AAC4D3", font = "Verdana 10 bold")
				self.lbs.grid(row=r,column=1)
				self.lbs.config(text = str(self.akt_status))
				self.lbk = tk.Label(self.statf, relief="raised", width=15, height=2, bg="#AAC4D3", font = "Verdana 10 bold")
				self.lbk.grid(row=r,column=2)
				self.lbk.config(text = str(self.korr))
				r += 1
		#########################################
		
		self.tick()
		self.fenster.after(2000, self.label_update)
		self.fenster.mainloop()
	
	def label_update(self):
		
		##### test hier labels updaten ????????? ######
		self.status = self.get_status()
		for status_lesen in self.status:
			status_lesen = list(status_lesen)
			self.name = status_lesen[4]
			self.akt_status = status_lesen[2]
			self.korr = status_lesen[3]
			if self.korr == 'k':
				self.korr = "ZEITKORREKTUR"
				
			print self.name,self.akt_status,self.korr,"1111" #wird richtig ausgegeben
			self.lbn.config(text = str(self.name))
			self.lbs.config(text = str(self.akt_status))
			self.lbk.config(text = str(self.akt_status))
		##################################################
			
		self.fenster.after(2000, self.get_status)
		self.fenster.after(2000, self.label_update)

def main():
	app = AppGUI()

if __name__ == '__main__':
	main()

@ganja: Das mag Dir egal sein was da steht aber wir müssen das ja auch lesen und verstehen was Du da machst. Und da sind schlechte, falsche, oder verstümmelte Namen halt nicht angenehm zu lesen. Und das kann dann so weit gehen das man etwas nicht versteht oder falsch versteht. So ein „Um gute Namen kümmere ich mich später“ findet erfahrungsgemäss auch spöter dann nicht statt wenn es läuft, weil dann läuft es ja. Bis es das mal nicht mehr tut und sich der Autor selber ärgert das sein eigener Code nach ein paar Monaten sauschwer zu lesen ist, weil dann die Bedeutung der schlechten Namen auch beim Autor nicht mehr im Gedächtnis präsent ist, und er sich mühsam durch den eigenen Quelltext kämpfen muss. Gute Namensgebung ist wichtiger Bestandteil vom Programmieren, von Anfang an, und nichts unwichtiges was man später vielleicht mal macht. Wenn man sich passende Namen überlegen muss, bedeutet das nämlich auch das man dabei über das zu lösende Problem nachdenken muss. Und wenn man keinen guten Namen für irgendetwas findet, hat man das Problem oder den eigenen Lösungsansatz in der Regel nicht ganz verstanden.

Ich glaube ich erwähnte schon mal das ``global`` in einer Methode so gar nichts zu suchen hat. Wenn man schon ein Objekt hat, braucht man keine globalen Variablen mehr.

Code nach einem ``return`` wird nicht ausgeführt! Du schliesst also die Datenbankverbindung nicht.

Das Umwandeln des Objekts was die Datenbank für einen Datensatz zurück gibt in eine Liste ist überflüssig. Genau so wie die ganzen `str()`-Aufrufe beim setzen des Texts der Labels. Das kann einem unter Python 2.x sogar um die Ohren fliegen wenn eine der Zeichenketten aus der Datenbank Sonderzeichen wie Umlaute in Namen enthält. Man sollte an der Stelle für Texte konsequent mit Unicode arbeiten, also auch die Datenbank und den Zugriff so konfigurieren das Unicode geliefert wird.

Die ganzen Werte in der Schleife wo die Labels erstellt werden haben auch nichts als Attribute auf dem Objekt zu suchen. Das sind einfach nur lokale Werte.

`r` wird ziemlich weit entfernt vom Ort entfernt initialisiert an dem der Name dann endlich verwendet wird. So etwas ist unübersichtlich.

Wiederholungen von Code und von Daten im Quelltext sollte man vermeiden. Wenn man da mal etwas ändern möchte, muss man das in jeder der Wiederholungen ändern, darf keine vergessen, und muss darauf achten das wirklich jede Stelle exakt gleich geändert wird. Das ist aufwändig und fehleranfällig.

Den Text eines Labels kann man auch gleich beim erstellen angeben und muss ihn nicht gleich danach per `config()` ändern.

Wenn Du alle Labels aktualisieren möchtest, dann musst Du Dir auch alle Label-Objekte merken und nicht nur die letzte Zeile die erstellt wurde. Das geht allerdings nur gut wenn sich die Anzahl der Ergebnisse der Datenbankabfrage nicht ändert, denn dann müsste man ja Zeilen in der Tabelle hinzufügen oder entfernen. In dem Fall würde ich einfach die alten Labels zerstören und die Anzeige immer neu aufbauen.

`self.get_status()` mittels `after()` aufzurufen macht keinen Sinn.

Hall BlackJack,

Code nach einem ``return`` wird nicht ausgeführt! Du schliesst also die Datenbankverbindung nicht.
Habe ich angepasst.

Die ganzen Werte in der Schleife wo die Labels erstellt werden haben auch nichts als Attribute auf dem Objekt zu suchen. Das sind einfach nur lokale Werte.
ich weiß leider nicht wo ich die Labels erzeugen soll.

Wiederholungen von Code und von Daten im Quelltext sollte man vermeiden. Wenn man da mal etwas ändern möchte, muss man das in jeder der Wiederholungen ändern, darf keine vergessen, und muss darauf achten das wirklich jede Stelle exakt gleich geändert wird. Das ist aufwändig und fehleranfällig.
Da stimme ich dir zu, aber ich weiß leider nicht, wie ich es machen soll!

Wenn Du alle Labels aktualisieren möchtest, dann musst Du Dir auch alle Label-Objekte merken und nicht nur die letzte Zeile die erstellt wurde. Das geht allerdings nur gut wenn sich die Anzahl der Ergebnisse der Datenbankabfrage nicht ändert, denn dann müsste man ja Zeilen in der Tabelle hinzufügen oder entfernen. In dem Fall würde ich einfach die alten Labels zerstören und die Anzeige immer neu aufbauen.
Mitlerweile denke ich auch das beste wäre die Labels zu löschen und neu zu erzeugen, aber ich weiß leider nicht wie ich das umsetzen soll.

`self.get_status()` mittels `after()` aufzurufen macht keinen Sinn.
Habe ich raus genommen

Ich werde das lassen, schade, aber ich komme nicht weiter ich verstehe es nicht und ich gebe auf.
Vilen Dank an euch alle die versucht haben mir zu helfen.

Überarbeitet und ungetestet:

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import absolute_import, division, print_function 
import Tkinter as tk
from contextlib import closing
from datetime import datetime as DateTime
import MySQLdb

BACKGROUND_COLOR = '#AAC4D3'
FONT = 'Verdana 10 bold'


def get_status():
    with closing(
        MySQLdb.connect('xxxxxxxxx', 'xxxx', 'xxx', 'xxxx')
    ) as connection:
        with closing(connection.cursor()) as cursor:
            cursor.execute(
                'SELECT idx, user, status, korrektur, name'
                '  FROM users'
                ' ORDER BY idx'
            )
            return list(cursor)


class AppGUI(object):

    def __init__(self):
        self.root = tk.Tk()
        self.root.title('ZEITERFASSUNG')
        self.root['background'] = BACKGROUND_COLOR

        # frame oben time dat
        frame = tk.Frame(
            self.root, background='yellow', relief=tk.SUNKEN, border=2
        )
        frame.pack(fill=tk.X, pady=1)
        options = {'relief': tk.GROOVE, 'background': 'white', 'font': FONT}
        self.date_label = tk.Label(frame, **options)
        self.date_label.pack(side=tk.RIGHT)
        self.clock_label = tk.Label(frame, **options)
        self.clock_label.pack(side=tk.RIGHT)

        # frame mitte label and buttons
        self.status_frame = tk.Frame(
            self.root, background='red', relief=tk.FLAT, border=2
        )
        self.status_frame.pack(fill=tk.X, pady=1)
        self.status_widgets = list()

        self.update_status()
        self.update_clock()
        self.root.mainloop()

    def update_clock(self):
        now = DateTime.now()
        self.date_label['text'] = format(now, '%Y-%m-%d')
        self.clock_label['text'] = format(now, '%H:%M:%S')
        self.root.after(500, self.update_clock)

    def update_status(self):
        for widget in self.status_widgets:
            widget.destroy()
        self.status_widgets = list()
        
        options = {
            'relief': tk.RAISED, 'background': BACKGROUND_COLOR, 'font': FONT
        }
        row_number = 0
        for _, _, state, correction, name in get_status():
            if correction == 'k':
                correction = 'ZEITKORREKTUR'

            if state == 'g':
                for column_number, text in enumerate([name, state, correction]):
                    label = tk.Label(self.status_frame, text=text, **options)
                    label.grid(row=row_number, column=column_number)
                    self.status_widgets.append(label)
                row_number += 1

        self.root.after(2000, self.update_status)


def main():
    AppGUI()


if __name__ == '__main__':
    main()

Hola BlackJack,
Das sieht vom code hier total anderest wie bei mir, ich hätte das in den nächsten 2 Jahren nicht geschaft so hin zu bekommen, du importiers sachen von denen ich noch nie etwas gehört habe.

Vielen Dank, gibt es irgend etwas wie ich dir Danken kann, kann ich etwas für dich tun, ich kann mich auch mit € bedanken, wirklich Vielen Dank, ich hätte es so nicht hin bekommen.

Ich wollte eine Pause von ein paar Monaten einlegen, bevor ich wieder mich an den code getraut hätte.

Ok, noch einmal Vilen Dank, und wenn es etwas gibt wo ich mich revanchieren kann bitte sag es.

So, jetzt keine Pause, jetzt gedanken machen, user kommt mit rfid meldet sich am terminal und will sein status ändern, es sollten 4 buttons zu verfügung gestellt werden und ein button cancel und ein par informationen aus def get_status() die ich erwetern werde wenn das geht, ich habe mir gedacht(rfid script zum auslesen habe ich bereits geschrieben und es tut es liest auch alle 2 sec am terminal und schreibt es in eine liste oder tupel weiß ich jetzt nicht muß ich nachschauen) das sich eine buttonbox öffnet und bestimmte auswahl zu verfügung gestellt wird, soll ich versuchen den rest hier einzubetten auslesen rfid, buttons zu verfügung stellen, oder , was ist der einfachste weg für einen lain das zu lösen?

Noch einmal Vilen Dank an BlackJack, auch an alle anderen Vielen Dank.

Hallo

mitlerweile habe ich es fertig, es sieht so aus wie ich mir das vorgestellt habe und es funktioniert so wie ich es mir vorgestellt habe.
Ein paar kleinigkeiten gibt es auch die nicht so schön sind, das flakern beim löschen und neu erstellen der labels und buttons, finde ich nicht so schön, vielleicht hat da jemand ein rat für mich wie ich das besser lösen kann.

Ist es möglich das flackern beim löschen und neu schreiben der Labels weg zu bekommen, das es nicht flackert?
Kann man nur den inhalt der Labels aktualisieren ohne das alle Labels und Buttons neu erstellt werden?
Ist es vielleicht besser den update der Labels und buttons an die buttons zu übergeben, d.h. wenn ein button geklickt wird soll erst dann das update erfolgen?

Ist es möglich die ganzen buttons funktionen in eine große funktion zu packen?

hier noch mal code erweitert

Vielen Dank
Gruß
ganja

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: utf-8 -*-

from __future__ import absolute_import, division, print_function
import Tkinter as tk
from contextlib import closing
from datetime import datetime as DateTime
import MySQLdb
import serial
## test
import time
##
#### test
ts = time.time()
sec = int(ts)
dat = time.strftime('%Y-%m-%d')
zeit = time.strftime('%H:%M:%S')
zeit1 = time.strftime('%H')

BACKGROUND_COLOR = '#AAC4D3'
FONT = 'Verdana 10 bold'
   
def get_status():
	with closing(
		MySQLdb.connect('xxxxxxx', 'xxxxx', 'xxxx', 'xxxxx')
	) as connection:
		with closing(connection.cursor()) as cursor:
			cursor.execute(
				'SELECT idx, user, status, korrektur, name'
				'  FROM users'
				' ORDER BY idx'
			)
	return list(cursor)

### noch nicht 
def read_rfid():
	ser = serial.Serial("/dev/ttyAMA0")
	ser.baudrate = 9600
	daten = ser.read(12)
	ser.close()    
	daten = daten.replace("\x02", "" )
	daten = daten.replace("\x03", "" )
	daten = daten.lstrip()
	return daten
	
###### funktioniert noch nicht
#def set_kommen():
#	rfidnr = (open("/home/kul/ze/test.txt").read())
#	#print(rfidnr,"111111")
#	with closing(
#		MySQLdb.connect('192.168.4.139', 'kul', 'ikul', 'c1kul')
#	) as connection:
#		with closing(connection.cursor()) as cursor:
#			cursor.execute(
#				'SELECT idx, status'
#				'FROM users' 
#				'WHERE RFID=%s' % (rfidnr)
#				#"WHERE RFID = '" + (rfidnr) + "' "  geht noch nicht!!!!
#			)
#	print(idx, status)

def set_kommen():
	rfidnr = open("/home/pi/ze/test.txt").read()
	db=MySQLdb.connect("xxxxxx","xxxxxxx","xxxx","xxxxxxx")
	cursor = db.cursor()
	stat = "SELECT idx, status FROM users WHERE RFID = '" + (rfidnr) + "'"
	cursor.execute(stat)
	row = cursor.fetchall()
	for row0 in cursor:
		idx_user = row0[0]
		status = row0[1]
		#print (idx_user, status)
	if status in ['g', '']:
		cursor.execute("UPDATE users SET status='k' WHERE idx = %s",(idx_user))
		cursor.execute("INSERT INTO Zeitstempel (idx, Datum, Uhrzeit, Sekunden, Status) VALUES (%s, %s, %s, %s, %s)",(idx_user,dat,zeit,sec,'k'))
	elif status in ['p', 'm', 'd']:
		#print(idx_user,status,"222222222")
		cursor.execute("UPDATE users SET status='k' WHERE idx = %s",(idx_user))
		cursor.execute("SELECT status, Uhrzeit FROM Zeitstempel WHERE idx = %s AND Datum = %s AND Status = %s Order by Sekunden DESC",(idx_user,dat,status))
		row5 = cursor.fetchall()
		for row5 in cursor:
			z1 = row5[1]
			status_new = row5[0]
			if z1 != 0:
				cursor.execute("INSERT INTO Arbeitszeit (idx, Datum, z1, z2, status) VALUES (%s, %s, %s, %s, %s)",(idx_user,dat,z1,zeit,status_new))
				cursor.execute("DELETE FROM Zeitstempel WHERE idx = %s AND status = %s AND Datum = %s",(idx_user,status_new,dat))
	cursor.close()
	db.close()

def set_pause():
	rfidnr = open("/home/pi/ze/test.txt").read()
	db=MySQLdb.connect("xxxxxxxx","xxxxxxxx","xxxxxx","xxxxx")
	cursor = db.cursor()
	status = "SELECT idx, status FROM users WHERE RFID = '" + (rfidnr) + "'"
	cursor.execute(status)
	row = cursor.fetchall()
	for row0 in cursor:
		idx_user = row0[0]
		status = row0[1]
		print (idx_user, status)
	cursor.execute("""UPDATE users SET status = 'p' WHERE idx = %s""",(idx_user))
	cursor.execute("""INSERT INTO Zeitstempel (idx, Datum, Uhrzeit, Sekunden, Status) VALUES (%s, %s, %s, %s, %s)""",(idx_user,dat,zeit,sec,'p'))
	cursor.close()
	db.close()

def set_mittag():
	rfidnr = open("/home/pi/ze/test.txt").read()
	db=MySQLdb.connect("xxxxxxxx","xxxxxxx","xxxxxxx","xxxxxxx")
	cursor = db.cursor()
	status = "SELECT idx, status FROM users WHERE RFID = '" + (rfidnr) + "'"
	cursor.execute(stat)
	row = cursor.fetchall()
	for row0 in cursor:
		idx_user = row0[0]
		status = row0[1]
		#print (idx_user, status)
	cursor.execute("UPDATE users SET status = 'm' WHERE idx = %s",(idx_user))
	cursor.execute("INSERT INTO Zeitstempel (idx, Datum, Uhrzeit, Sekunden, Status) VALUES (%s, %s, %s, %s, %s)",(idx_user,dat,zeit,sec,'m'))
	cursor.close()
	db.close()

def set_dienstgang():
	rfidnr = open("/home/pi/ze/test.txt").read()
	db=MySQLdb.connect("xxxxxxx","xxxxx","xxx","xxxxx")
	cursor = db.cursor()
	status = "SELECT idx, status FROM users WHERE RFID = '" + (rfidnr) + "'"
	cursor.execute(stat)
	row = cursor.fetchall()
	for row0 in cursor:
		idx_user = row0[0]
		status = row0[1]
		#print (idx_user, status)
	cursor.execute("UPDATE users SET status = 'd' WHERE idx = %s", (idx_user))
	cursor.execute("INSERT INTO Zeitstempel (idx, Datum, Uhrzeit, Sekunden, Status) VALUES (%s, %s, %s, %s, %s)",(idx_user,dat,zeit,sec,'d'))
	cursor.close()
	db.close()

def set_gehen():
	rfidnr = open("/home/pi/ze/test.txt").read()
	db=MySQLdb.connect("xxxxxxxx","xxxxx","xxxxxx","xxxxx")
	cursor = db.cursor()
	stat = "SELECT idx, status FROM users WHERE RFID = '" + (rfidnr) + "'"
	cursor.execute(stat)
	row = cursor.fetchall()
	for row0 in cursor:
		idx_user = row0[0]
		status = row0[1]
		#print (idx_user, status)
	cursor.execute("UPDATE users SET status = 'g' WHERE idx = %s",(idx_user))
	cursor.execute("SELECT Status, Uhrzeit FROM Zeitstempel WHERE idx = %s AND Datum = %s AND Status = %s ORDER BY Sekunden DESC",(idx_user,dat,status))
	row8 = cursor.fetchall()
	for row8 in cursor:
		status_new = row8[0]
		z1new = row8[1]
		if (row8 != 0):
			cursor.execute("INSERT INTO Arbeitszeit (idx, Datum, z1, z2, status) VALUES (%s, %s, %s, %s, %s)",(idx_user,dat,z1new,zeit,'A'))
			cursor.execute("DELETE FROM Zeitstempel WHERE status = %s AND Datum = %s AND idx = %s",(status_new,dat,idx_user))
	cursor.close()
	db.close()
	
class AppGUI(object):
	def __init__(self):
		self.root = tk.Tk()
		self.root.title('ZEITERFASSUNG')
		self.root['background'] = BACKGROUND_COLOR
		self.root.geometry("800x650")#+24+10
	
		# frame oben time dat
		frame = tk.Frame(
			self.root, background='#AAC4D3', relief=tk.SUNKEN, border=2
		)
		frame.pack(fill=tk.X, pady=1)
		options = {'relief': tk.GROOVE, 'background': 'white', 'font': FONT}
		self.date_label = tk.Label(frame, **options)
		self.date_label.pack(side=tk.RIGHT)
		self.clock_label = tk.Label(frame, **options)
		self.clock_label.pack(side=tk.RIGHT)
     
		# frame mitte label and buttons
		self.status_frame = tk.Frame(
			self.root, background='#AAC4D3', relief=tk.FLAT, border=2
		)
		self.status_frame.pack(fill=tk.X, pady=1)
		self.status_widgets = list()

		self.update_status()
		self.update_clock()
		self.root.mainloop()
     
	def update_clock(self):
		now = DateTime.now()
		 self.date_label['text'] = format(now, '%Y-%m-%d')
		self.clock_label['text'] = format(now, '%H:%M:%S')
		self.root.after(500, self.update_clock)
     
	def update_status(self):
		for widget in self.status_widgets:
			widget.destroy()
		self.status_widgets = list()
		   
		options = {
			'relief': tk.RAISED, 'background': BACKGROUND_COLOR, 'font': FONT, 'width': 15, 'height': 2
		}
		row_number = 0
		for _, _, state, correction, name, in get_status():
			if correction == 'k':
				correction = 'ZEITKORREKTUR'
				
			if state == 'g':
				state = 'abwesend'
				for column_number, text in enumerate([name, state, correction]):#, urlaub, resturlaub]):
					label = tk.Label(self.status_frame, text=text, **options)
					label.grid(row=row_number, column=column_number)
					self.status_widgets.append(label)
					button = tk.Button(self.status_frame, relief="raised", width=5, height=1, bg='green', font = "Verdana 10 bold",text='kommen', command=set_kommen)
					button.grid(row=row_number, column=5)
					self.status_widgets.append(button)
				row_number += 1
			elif state == 'p':
				state = 'pause'
				for column_number, text in enumerate([name, state, correction]):#, urlaub, resturlaub]):
					label = tk.Label(self.status_frame, text=text, relief="raised", width=15, height=2, bg="yellow", font = "Verdana 10 bold")#**options)
					label.grid(row=row_number, column=column_number)
					self.status_widgets.append(label)
					button = tk.Button(self.status_frame, relief="raised", width=5, height=1, bg='green', font = "Verdana 10 bold",text='kommen', command=set_kommen)
					button.grid(row=row_number, column=5)
					self.status_widgets.append(button)
				row_number += 1
			elif state == 'm':
				state = 'mittag'
				for column_number, text in enumerate([name, state, correction]):#, urlaub, resturlaub]):
					label = tk.Label(self.status_frame, text=text,  relief="raised", width=15, height=2, bg="yellow", font = "Verdana 10 bold")#**options)
					label.grid(row=row_number, column=column_number)
					self.status_widgets.append(label)
					button = tk.Button(self.status_frame, relief="raised", width=5, height=1, bg='green', font = "Verdana 10 bold",text='kommen',command=set_kommen)
					button.grid(row=row_number, column=5)
					self.status_widgets.append(button)
				row_number += 1
			elif state == 'd':
				state = 'dienstgang'
				for column_number, text in enumerate([name, state, correction]):#, urlaub, resturlaub]):
					label = tk.Label(self.status_frame, text=text, relief="raised", width=15, height=2, bg="blue", font = "Verdana 10 bold")#**options)
					label.grid(row=row_number, column=column_number)
					self.status_widgets.append(label)
					button = tk.Button(self.status_frame, relief="raised", width=5, height=1, bg='green', font = "Verdana 10 bold",text='kommen',command=set_kommen)
					button.grid(row=row_number, column=5)
					self.status_widgets.append(button)
				row_number += 1
			elif state == 'k':
				state = 'anwesend'
				for column_number, text in enumerate([name, state, correction]):#, urlaub, resturlaub]):
					label = tk.Label(self.status_frame, text=text, relief="raised", width=15, height=2, bg="green", font = "Verdana 10 bold")#**options)
					label.grid(row=row_number, column=column_number)
					self.status_widgets.append(label)
					button_pause = tk.Button(self.status_frame, relief="raised", width=4, height=1, bg='yellow', font = "Verdana 10 bold",text='pause',command=set_pause)
					button_pause.grid(row=row_number, column=6)
					button_mittag = tk.Button(self.status_frame, relief="raised", width=4, height=1, bg='yellow', font = "Verdana 10 bold",text='mittag',command=set_mittag)
					button_mittag.grid(row=row_number, column=7)
					button_dienstgang = tk.Button(self.status_frame, relief="raised", width=7, height=1, bg='blue', font = "Verdana 10 bold",text='dienstgang', command=set_dienstgang)
					button_dienstgang.grid(row=row_number, column=8)
					button_gehen = tk.Button(self.status_frame, relief="raised", width=4, height=1, bg='red', font = "Verdana 10 bold",text='gehen',command=set_gehen)
					button_gehen.grid(row=row_number, column=9)
					self.status_widgets.append(button_pause)
					self.status_widgets.append(button_mittag)
					self.status_widgets.append(button_dienstgang)
					self.status_widgets.append(button_gehen)
				row_number += 1
			elif state == '!':
				state = 'unbekannt'
				for column_number, text in enumerate([name, state, correction]):#, urlaub, resturlaub]):
					label = tk.Label(self.status_frame, text=text, relief="raised", width=15, height=2, bg="dark-red", font = "Verdana 10 bold")#**options)
					label.grid(row=row_number, column=column_number)
					self.status_widgets.append(label)
				row_number += 1
				
		self.root.after(2000, self.update_status)
	
def main():
	AppGUI()
         
if __name__ == '__main__':
	main()

@ganja: Man will keine grossen Funktionen sondern kleine, die man leicht überschauen kann. Man kann bei den ganzen Codewiederholungen aber sicher noch gemeinsame Teile aus den Funktionen herausziehen. Und man könnte statt der einzelnen Funktionen mal überlegen die Geschäftslogik objektorientiert zu modellieren. Zum Beispiel ein `User`-Typ der die relevanten Daten enthält und Methoden um den Status zu ändern und so weiter.

Die globalen Variablen am Anfang des Moduls gehören da nicht hin. So wie die verwendet werden funktioniert das auch gar nicht. Schau Dir mal die Zeitstempel an die in der Datenbank landen. Beziehungsweise landen würden wenn da mal irgendwo ein `commit()` gemacht würde.

Warum gibt es auf jedem Label diese Buttons obwohl die doch gar nicht zum Label gehören‽ Wer an-, ab-, oder umgemeldet wird entscheidet doch anscheinend der RFID-Tag, auch wenn der Besitzer von dem Tag auf einen Button von einem anderen Benutzer drückt. Das ist verwirrend.

Den Inhalt der Labels könntest Du aktualisieren wenn Du die irgendwie identifizieren könntest. Und das würde auch nur dann ohne Veränderung der GUI Funktionieren wenn kein Benutzer hinzukommt oder weggeht.

Die `update_status()`-Methode ist zu lang, da sind auch zu viele Wiederholungen drin.

Hatte ich schon mal SQLAlchemy für den Datenbankzugriff erwähnt? Mit dem ORM wird es auch einfacher beziehungsweise ziemlich einfach eine `User`-Klasse zu schreiben.

@ganja: Die `fetchall()`-Aufrufe mit den Schleifen wenn nur *ein* Datensatz erwartet wird sind komisch. Es gibt `fetchone()`. Was auch komisch ist, beziehungsweise sogar falsch ist erst `fetchall()` auf dem Cursor-Objekt aufrufen, dann nicht mit dem Ergebnis machen ausser es an einen Namen zu binden der sehr unpassend ist (`row` für etwas das *mehrere* Datensätze repräsentiert), und *danach* dann über den Cursor zu iterieren! Ich hätte ehrlich gesagt nicht erwartet dass das funktioniert, und das ist so auch nicht dokumentiert.

Die angehängten Ziffern an die `row`-Namen sind dann auch sehr unschön. Ebenso die Indexzugriffe auf die Datensätze mit den ”magischen” Zahlen. Binde die Elemente besser an sprechende Bezeichner, dann lässt sich das leichter lesen und verstehen.

Das aufteilen des einen Zeitstempel-Wertes auf drei Spalten würde man besser als *einen* Wert in der Datenbank speichern. Der gesamte Entwurf kommt mir komisch bis unnötig Komplex vor. Warum nicht nur Arbeitszeit und am Anfang wird die Endzeit halt auf NULL gesetzt und erst wenn die Eingetragen ist, haben wir einen kompletten Eintrag. Desweiteren darf es pro Benutzer nur einen Eintrag mit NULL bei der Endzeit geben. Dann könnte man den aktuellen Status auch in dem Arbeitszeit-Datensatz speichern und muss den nicht beim Benutzer speichern.

In `set_gehen()` ist ein Fehler: `row8` ist *immer* ungleich 0. Ich verstehe den Sinn dieser Bedingung sowieso nicht wirklich.

Die Tabellen mal mit SQLAlchemy's ORM modelliert (mit geratenen Spaltentypen und ungetestet):

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import absolute_import, division, print_function
from datetime import datetime as DateTime

from sqlalchemy import CHAR, Column, DATE, ForeignKey, INTEGER, TIME, VARCHAR
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import object_session, relationship


Base = declarative_base()


class User(Base):

    __tablename__ = 'users'

    id = Column('idx', INTEGER, primary_key=True)
    # user = Column(?)  Wird in einer Abfrage erwähnt aber nirgends verwendet.
    status = Column(CHAR(1), nullable=False, default='!')
    correction = Column('korrektur', CHAR(1), nullable=False)
    name = Column(VARCHAR(200), nullable=False)
    rfid = Column('RFID', VARCHAR(100), unique=True)

    # `timestamps` as backreference from `Timestamp`
    # `worktimes` as backreference from `Worktime`

    def _add_timestamp(self, now=None):
        self.timestamps.append(Timestamp.now(self, now))

    def _timestamp2worktime(self, worktime_status, new_status):
        session = object_session(self)
        # 
        # Frage warum kann es hier mehr als einen Eintrag geben?  Darf das
        # überhaupt sein?
        # 
        timestamps = (
            session.query(Timestamp)
                .filter_by(date=now.date(), status=self.status)
                .order_by(Timestamp.seconds)
                .desc()
                .all()
        )
        for timestamp in timestamps:
            if timestamp.time != 0:
                session.add(
                    Worktime(
                        user=self,
                        date=timestamp.date(),
                        start_time=timestamp.time,
                        end_time=now.time(),
                        status=worktime_status,
                    )
                )
                break
                # Ich hoffe ich habe die Logik an der Stelle äquivalent
                # umgesetzt.
        for timestamp in timestamps:
            session.delete(timestamp)
        self.status = new_status

    def start_work(self):
        now = DateTime.now()
        if self.status in ['g', ' ']:
            self.status = 'k'
            self._add_timestamp(now)
        elif self.status in ['p', 'm', 'd']:
            self._timestamp2worktime(self.status, 'k')

    def start_break(self):
        self.status = 'p'
        self._add_timestamp()

    def start_lunch_break(self):
        self.status = 'm'
        self._add_timestamp()

    def start_business_errand(self):
        self.status = 'd'
        self._add_timestamp()

    def stop_work(self):
        self._timestamp2worktime('A', 'g')

    @classmethod
    def get_all(cls, session):
        return session.query(cls).all()

    @classmethod
    def get_by_rfid(cls, session, rfid):
        return session.query(cls).filter_by(rfid=rfid).one()


class Timestamp(Base):

    __tablename__ = 'Zeitstempel'

    id = Column(INTEGER, primary_key=True)
    user_id = Column('idx', INTEGER, ForeignKey(User), nullable=False)
    date = Column('Datum', DATE, nullable=False)
    time = Column('Uhrzeit', TIME, nullable=False)
    seconds = Column('Sekunden', INTEGER, nullable=False)
    status = Column('Status', CHAR(1), nullable=False)

    user = relationship(User, backref='timestamps')

    @classmethod
    def now(cls, user, now=None):
        if now is None:
            now = DateTime.now()
        return cls(
            user=user,
            date=now.date(),
            time=now.time().replace(second=0),
            seconds=now.second,
            status=user.status,
        )


class Worktime(Base):

    __tablename__ = 'Arbeitszeit'

    id = Column(INTEGER, primary_key=True)
    user_id = Column('idx', ForeignKey(User))
    date = Column('Datum', DATE, nullable=False)
    start_time = Column('z1', TIME, nullable=False)
    end_time = Column('z2', TIME, nullable=False)
    status = Column(CHAR(1), nullable=False)

    user = relationship(User, backref='worktimes')

Guten Morgen,
Vielen Dank BlackJack das du dir wieder die mühe gemacht hast.
Sorry das ich nicht sofort feedback gegeben habe, war verhindert.

deine erste bemerkung,
`fetchone()`,`fetchall()`, das kenne ich, aber aus irgend einem grund hat es nur so funktioniert im shell script.

zweite,
werde ich in zukunft versuchen

drittens,
Das kann ich dir nicht sagen die DB ist schon vorhanden, und wie gesagt shell script funktioniert, warum man das so in der DB gemacht hat das weiß ich nicht, vielleicht auch unwissen wie bei mir.

viertens,
SQLAlchemy's ORM, davon habe ich noch nie etwas gehört bis du es erwennt hast, musste das modul nachinstallieren, muß aber jetzt erstmal mich da einbisschen einlesen.

dein code muss ich jetzt auch mal zeile für zeile durchgehen, um zu verstehen was da passiert

rfid = Column('RFID', VARCHAR(100), unique=True) ist in der DB ein BIGINT

mit den Tabellen liegst nicht viel falsch.
Leider habe ich jetzt keine ahnung ob man die 2 files zu einem macht oder ob das 2 eigenständige files bleiben und dan nur importiert zu einander werden.

Noch einmal Vielen Dank das du dir die mühen gemacht hast, ich muß noch viel viel lernen, damit es besser wird.

Hallo,
ich brauche nochmal kurz hilfe, ich möchte gerne alle user die da sind grün anzeigen, aber ich habe keine ahnung wie, wenn ich nur ein Label hätte dann wäre das kein Problem, aber hier in diesem fall komme ich nicht drauf wo ich background verändern soll wie gesagt nur die user die <anwesend> sind.

Danke im Voraus

Code: Alles auswählen

# ...
        row_number = 0
		for _, user, state, correction, _, in get_status():
			if correction == 'k':
				correction = 'ZEITKORREKTUR'
			if state == 'k':
				state = 'anwesend'

			if state == 'p':
				state = 'pause'

			if state == 'm':
				state = 'mittag'

			if state == 'd':
				state = 'dienstgang'

			if state == 'g':
				state = ''
				
			for column_number, text in enumerate([user, state, correction]):
				label = tk.Label(self.status_frame, text=text, **options)
				label.grid(row=row_number, column=column_number)
				self.status_widgets.append(label)
			row_number += 1

@ganja: die if-nicht-Kaskade könntest Du besser durch ein Wörterbuch abbilden. Für row_number kannst du auch enumerate benutzen. Wo ist das Problem, dem Label ein background-Attribut zu geben?

Code: Alles auswählen

for row_number, (_, user, state, correction, _) in enumerate(get_status()):
    if correction == 'k':
        correction = 'ZEITKORREKTUR'
    state = {
        'k': 'anwesend',
        'p': 'pause',
        'm': 'mittag',
        'd': 'dienstgang',
        'g': '',
    }[state]
    options['background'] = 'red' if state == 'anwesend' else 'green'
    for column_number, text in enumerate([user, state, correction]):
        label = tk.Label(self.status_frame, text=text, **options)
        label.grid(row=row_number, column=column_number)
        self.status_widgets.append(label)

erst einmal Vielen Dank sirius, es ist kann Problem wenn man es kann!
Ich möchte nur den user green haben, mit deinem code bekomme ich den user, state und correction grün, nach dem ich die if bedienung umgedreht habe.
das ist nicht ganz was ich will, es soll nur der user grün sein, state und correction sollen die farbe von frame haben, da blicke ich es nicht durch wo ich für den user und nur den user die farbe setzte.

Gruß
ganja

Das deutsche Python-Forum

listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff

Re: listen zugriff