gui - datenbank (tabelle)

Stellt hier eure Projekte vor.
Internetseiten, Skripte, und alles andere bzgl. Python.
tabellar
User
Beiträge: 186
Registriert: Mittwoch 4. September 2002, 15:28

Sonntag 26. Juni 2005, 11:13

Hi Rolgal,

ich hab auch ein bisschen weiter gemacht... :

Code: Alles auswählen

class TableWrapper:
    """dbwrapper"""
    def __init__(self):
        """init"""

    def connect(self,DbType,Host,Db,User):

        if DbType=='PgSQL':
           import pgsqlDAO 
           self.dbWrapper=pgsqlDAO.PgSqlDAO()
           self.dbWrapper.connect(Host,Db,User)

        if DbType=='MySQL':
           import mysqlDAO 
           self.dbWrapper=mysqlDAO.MySqlDAO()
           self.dbWrapper.connect(Host,Db,User)

        if DbType=='XML':
           import xmlDAO
           self.dbWrapper=xmlDAO.XmlDAO()
           self.dbWrapper.connect(Host,Db,User)           
           
    def getTableNameList(self):
        return self.dbWrapper.getTableNameList()

    def getTableColumnsList(self,tableName):
        return self.dbWrapper.getTableColumnsList(tableName)
    
    def getTableColumnsData(self,tableName):
        return self.dbWrapper.getTableColumnsData(tableName)

    def insertTableColumnsData(self,tableName,colList,valueList):
        self.dbWrapper.insertTableColumnsData(tableName,colList,valueList)
        
    def close(self):
        self.dbWrapper.close()
Du siehst, ich habe die "import" Anweisung in die if-condition gesteckt. Bei den Methoden siehst du jetzt ausserdem, dass überall entsprechende Argumente (tableName, etc. ) übergeben werden können. Sprich, keine "fixe" Tabellenverdrahtung mehr.

Code: Alles auswählen

        #Instantiierung DbWrapper... 
        self.tablewrapper=tableWrapper.TableWrapper()

        #Auswahl der Datenbank
        self.tablewrapper.connect('XML','10.2.0.1','db.xml','userName')
        #self.tablewrapper.connect('PgSQL','10.2.0.1','dbname','useName')

        #Festlegung der Tabelle 
        self.db_tables=self.tablewrapper.getTableNameList()
        self.db_table=self.db_tables[0]
        self.cols_names=self.tablewrapper.getTableColumnsList(self.db_table)
Hier ist der code für die "Datenbank- und Tabellenauswahl" im Konstruktor der "Hauptfenster" Klasse. Die Auswahl der XML DB ist jetzt auch dynamisch (allerdings hat sich die xmlDAO auch entspr. verändert).
rolgal hat geschrieben:<snip> ... im konstruktor des mysqlDAO folgendes dictionary:

Code: Alles auswählen

    def __init__(self):

        self.actions={"all":"select * from %s","sort":"select %s from %s order by %s"}
</snip>

Hm, ich bin nicht so der Freund von einzelnen SQL Commands in Dictionarys etc. Ich finde, dass die Übersichtlichkeit im Programm verloren geht. Ich persönlich finde es schöner, wenn sich die Funktionalität in den einzelnen Methodenaufrufen wiederspiegelt. Ausserdem haben wir bei der XML DB keine SQL Commands. Also wäre hier das Pendant zu deinem SQL-Dict eine neue Methode in der TableWrapper Class:

Code: Alles auswählen

def getTableColumnsDataSort(self,tableName,colNames,orderChoice):
        return self.dbWrapper.getTableColumnsDataSort(tableName,colNames,orderChoice)
Ich persönlich würde diese Form vorziehen, zumal es auch eine Art "Black Box" darstellt. ich warte aber mal, was du dazu meinst ... :wink: Ein nächster schöner Schritt wäre es, im DB-Client per Dialog die entsprechende Datenbank und die Tabellen auszuwählen...

Gruss Tabellar

PS: Vielleicht können wir dann bald den DB-Client für den "SQLator" verwenden ... :wink:
Gast

Sonntag 26. Juni 2005, 11:26

hallo tabellar,


Hm, ich bin nicht so der Freund von einzelnen SQL Commands in Dictionarys etc. Ich finde, dass die Übersichtlichkeit im Programm verloren geht.
man könnte das dictionary in eine datei auslagern und über pickle laden, irgendwie gefällt es mir besser wenn es für alle funktionen, die schlussendlich dasselbe tun, also z.b. lesen, es eine methode gibt. ich muss dir aber ehrlich sagen, dass das eine bauchsache ist. ich kann das nicht wirklich argumentieren.

wäre interessant zu wissen, was blackjack, leonidas u.a. python-gurus dazu meinen.
Ich persönlich würde diese Form vorziehen, ich warte aber mal, was du dazu meinst ... Wink Ein nächster schöner Schritt wäre es, im DB-Client per Dialog die entsprechende Datenbank und die Tabellen auszuwählen...
ich möchte zuerst wieder die ursprgl. funktionalität herstellen.
davor sollten wir uns einigen wie wir obigen punkt lösen, dann häng ich mich wieder in die tasten, zeitlich wird es bei mir nämlich bald wieder besser :D

liebe grüße

rolgal
tabellar
User
Beiträge: 186
Registriert: Mittwoch 4. September 2002, 15:28

Sonntag 26. Juni 2005, 12:24

Hi rolgal,

ich hätte zu dem Thema mal folgenden guten Link. und hier auch noch.

Thema hier ist die parametrisierte Form von cursor.execute und die Vermeidung von "SQL-Injection-Angriffen" (quoten der Input Werte durch den Escape-Mechanismus der DB-API). Solange wir diese Dinge bei unseren SQL Commands der Form

Code: Alles auswählen

"select %s from %s order by %s"
beachten, sind wir in der schlussendlichen Implementierung frei.

rolgal hat geschrieben:...man könnte das dictionary in eine datei auslagern und über pickle laden, irgendwie gefällt es mir besser wenn es für alle funktionen, die schlussendlich dasselbe tun, also z.b. lesen, es eine methode gibt. ich muss dir aber ehrlich sagen, dass das eine bauchsache ist. ich kann das nicht wirklich argumentieren.

wäre interessant zu wissen, was blackjack, leonidas u.a. python-gurus dazu meinen.
Ja, gute Idee, vielleicht meldet sich ja der ein oder andere dazu ... :wink: ?
rolgal hat geschrieben:ich möchte zuerst wieder die ursprgl. funktionalität herstellen. davor sollten wir uns einigen wie wir obigen punkt lösen, dann häng ich mich wieder in die tasten, zeitlich wird es bei mir nämlich bald wieder besser :D
Gut. Eine gemeinsame Lösung, die auch noch OPTIMAL im Sinne der DB Abfrage ist, wäre natürlich der Hit.... :P Das sollten wir doch schaffen, oder :wink: ???

Gruassle Tabellar
Gast

Sonntag 26. Juni 2005, 12:35

hi tabellar,
ich hätte zu dem Thema mal folgenden guten Link. und hier auch noch.

Thema hier ist die parametrisierte Form von cursor.execute und die Vermeidung von "SQL-Injection-Angriffen" (quoten der Input Werte durch den Escape-Mechanismus der DB-API). Solange wir diese Dinge bei unseren SQL Commands der Form
Python-Code:
"select %s from %s order by %s"
beachten, sind wir in der schlussendlichen Implementierung frei.

das heisst nachstehende funktion passt so net, weil es nicht im execute geschieht? ganz blick ich bei der problematik net durch, habe aber in der eile die links nur überflogen.
kannst mir mal schnell in 2, 3 sätzen das verdeutlichen?

Code: Alles auswählen


    def getTableColumnsData(self,a_type,*values):

        action=self.actions[a_type]
        for element in values:
            action=action%element
           
        cursor=self.conn.cursor()
        cursor.execute(action)
        result=cursor.fetchall()
        cursor.close()
        return result 
Gut. Eine gemeinsame Lösung, die auch noch OPTIMAL im Sinne der DB Abfrage ist, wäre natürlich der Hit.... Razz Das sollten wir doch schaffen, oder Wink ???
ein freund sagte in einer meiner krisen mal zu mir: aufgeben tut man briefe...

seit dem halte ich mich dran :D

abgesehen davon gibts hier keine krise, sondern ein großes teil, das halt nur in kleinen schritten zusammengesetzt werden kann


grüße

rolgal
Leonidas
Administrator
Beiträge: 16024
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Sonntag 26. Juni 2005, 12:39

tabellar hat geschrieben:Thema hier ist die parametrisierte Form von cursor.execute und die Vermeidung von "SQL-Injection-Angriffen" (quoten der Input Werte durch den Escape-Mechanismus der DB-API). Solange wir diese Dinge bei unseren SQL Commands der Form

Code: Alles auswählen

"select %s from %s order by %s"
beachten, sind wir in der schlussendlichen Implementierung frei.
Solange die DB Module pyformat nutzen, wenn es aber ein anderer paramstyle ist könnte das wiederrum Probleme bereiten.
tabellar hat geschrieben:
rolgal hat geschrieben:wäre interessant zu wissen, was blackjack, leonidas u.a. python-gurus dazu meinen.
Ja, gute Idee, vielleicht meldet sich ja der ein oder andere dazu ... :wink: ?
Ist schon nett als Guru bezeichnet zu werden, jedoch bin ich mit Datenbanken nicht so vertraut, also solltet ihr da besser auf die Meinung von BlackJack warten, bevor ich hier irgendwelchen Schrott erzähle.
Ich persönlich würde aber zur "Black Box"-Variante von Tabellar tendieren, schaut mir irgendwie "sauberer" aus (obwohl die Funktionsnamen etwas kürzer sein dürften *g*).
My god, it's full of CARs! | Leonidasvoice vs Modvoice
tabellar
User
Beiträge: 186
Registriert: Mittwoch 4. September 2002, 15:28

Sonntag 26. Juni 2005, 18:35

rolgal hat geschrieben:... das heisst nachstehende funktion passt so net, weil es nicht im execute geschieht? ganz blick ich bei der problematik net durch, habe aber in der eile die links nur überflogen.
kannst mir mal schnell in 2, 3 sätzen das verdeutlichen?
Ich versuchs mit dem Zitat von Gerhard Häring (sollte allgemein bekannt sein):
Gerhard Häring hat geschrieben: /me setzt Hut als PySQLite-Entwickler auf ;-)

Die Python DB-API 2.0 [*] sieht vor, dass man mit der execute-Methode
eines Cursors-Objekts den SQL-String und die einzufügenden Werte trennt.
Dadurch können die Werte von dem verwendeten Datenbankmodul automatisch
richtig gequotet werden.

>>> import sqlite
>>> sqlite.paramstyle
'pyformat'

PyFormat heisst, dass als Platzhalter %s verwendet werden soll [**].

.execute(operation[,parameters])

=> cursor.execute hat zwei Parameter, der erste ist der SQL-String, der
zweite, optionale, sind die Parameter.

Beispiel:

cu.execute("insert into mytable(a, b) values (%s, %s)", (a, b))

Ganz egal, von welchem Typ die Spalten bzw. Variablen a und b sind, sie
werden vom DB-API Modul richtig gequotet.
Ich hab mich nochmal intensiv mit der Thematik und deinem Funktionsvorschlag beschäftigt. Prinzipiell funktioniert deine Lösung recht gut mit dem SQL-Dict und ist natürlich auch schön kompakt von der Programmierung her. Aber eben nur bei klassischen DB Abfragen (SELECT ... FROM ... ORDER BY ...), da du den SQL-Query (action) vor der cursor.execute Methode schon durch entsprechende Parameterzuweisungen auflöst.

Bei den "INSERT INTO..." Befehlen funktioniert das ganze nicht mehr, wenn man sich an die DB API 2.0 Anweisung halten möchte, da eben in der execute Methode der SQL String und die VALUES getrennt werden sollen. Sprich die Auflösung einer INSERT Action im SQL Dict wie z.B. "INSERT INTO %s %s VALUES %s ;" und eine Trennung bei der cursor.execute(sql,[]) Methode in SQL und Parameter funktionieren nicht mehr.

Gruassle Tabellar
Gast

Sonntag 26. Juni 2005, 19:37

hallo tabellar,

ganz check ich das noch net, ist aber wohl egal, wir machen einfach mal wie du vorgeschlagen hast.

aber wann weisen wir die tabelle zu ?

cu.execute("insert into mytable(a, b) values (%s, %s)", (a, b))
mfg

rolgal
tabellar
User
Beiträge: 186
Registriert: Mittwoch 4. September 2002, 15:28

Sonntag 26. Juni 2005, 21:54

Hi rolgal,

bin gerade von .de nach .at gedüst... Ja, die Sache mit der DB API 2.0 execute Geschichte braucht ein wenig Gewöhnungszeit...
rolgal hat geschrieben:hallo tabellar,

ganz check ich das noch net, ist aber wohl egal, wir machen einfach mal wie du vorgeschlagen hast.
aber wann weisen wir die tabelle zu ?
Der SQL Query String wird bis auf die "Values" für die execute Methode vorbereitet, so dass dann SQL und Values übrig bleibt. Hier mal mein Beispiel vom PgSqlDAO Modul:

Code: Alles auswählen

    def insertTableColumnsData(self,tableName,colList,valueList):
        cur=self.con.cursor()        
        cols = ", ".join(colList)
        value_placeholders = ", ".join(["%s"] * len(colList))
        sql = """insert into %(tableName)s (%(cols)s)
                 values (%(value_placeholders)s)""" % locals()
        cur.execute(sql, valueList)
        self.con.commit()
Das ganze sieht wild aus, ergibt sich aber durch die dynamische Spalten und Value Listen. Das ganze ist an Gerhard Härings Methode angelehnt. Das ganze müsste eigentlich 1:1 in MySQL funktionieren.

Gruss Tabellar
tabellar
User
Beiträge: 186
Registriert: Mittwoch 4. September 2002, 15:28

Montag 27. Juni 2005, 21:20

Nach entsprechender Recherche vielleicht doch noch mal ne kurze Erklärung. Die DB API 2.0 Cursor Klasse mit ihrer execute Methode kann optional auch parametrisiert verwendet werden. Diese sog. paramstyles werden von den einzelnen DB API 2.0 Modulen zum Teil unterschiedlich unterstützt. Das SQLite Manual bietet eine gute Erklärung für das Ganze. Ich hab mal ein paar Beispiele zusammengestellt.


PostgreSQL:
PgSQL-Modul
paramstyle='pyformat'

SQLite:
pysqlite2.dbapi2-Modul
paramstyle='qmark'
paramstyle='named'

Code: Alles auswählen

#paramstyle='pyformat'
tableName="myTable"
cols="(feld1,feld2)"
values=('aaa',111)
valueparas="(%s,%s)"
sql="INSERT INTO %(tableName)s %(cols)s VALUES %(valueparas)s" % locals()
cur.execute(sql,values)

Code: Alles auswählen

#paramstyle='pyformat'
cur.execute("INSERT INTO myTable (feld1,feld2) VALUES (%s,%s)",('aaa',111))

Code: Alles auswählen

#paramstyle='qmark'
who = "Yeltsin"
age = 72
cur.execute("select name_last, age from people where name_last=? and age=?", (who, age))

Code: Alles auswählen

#paramstyle='named'
who = "Yeltsin"
age = 72
cur.execute("select name_last, age from people where name_last=:who and age=:age",locals())

Code: Alles auswählen

#paramstyle='named'
who = "Yeltsin"
age = 72
cur.execute("select name_last, age from people where name_last=:who and age=:age",{"who": who, "age": age})
Tabellar :wink:
Benutzeravatar
jens
Moderator
Beiträge: 8483
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Dienstag 28. Juni 2005, 07:49

tabellar hat geschrieben:

Code: Alles auswählen

#paramstyle='pyformat'
tableName="myTable"
cols="(feld1,feld2)"
values=('aaa',111)
valueparas="(%s,%s)"
sql="INSERT INTO %(tableName)s %(cols)s VALUES %(valueparas)s" % locals()
cur.execute(sql,values)
Warum arbeitest du eigentlich mich locals() ??? Es geht doch auch so:

Code: Alles auswählen

#paramstyle='pyformat'
sql="INSERT INTO %(tableName)s %(cols)s VALUES %(valueparas)s" % {
        tableName:  "myTable",
        cols:       "(feld1,feld2)",
        valueparas: "(%s,%s)"
    }
    
values=('aaa',111)
cur.execute(sql,values)
Meine Allgemeine SQL Klasse hast du aber auch schon gesehen: http://www.python-forum.de/viewtopic.php?p=20313#20313
Ist zwar speziell für mySQLdb, hilft dir vielleicht aber trotzdem...

Die "valueparas" erzeuge ich z.B. so: ",".join( ["%s"]*len(values) ) für "%s" könnte man auch gleich einen String nehmen, den man durch den paramstyle festlegt... Wobei das so einfach nur für 'qmark' und 'format' klappt :(

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
Leonidas
Administrator
Beiträge: 16024
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Dienstag 28. Juni 2005, 11:39

jens hat geschrieben:Warum arbeitest du eigentlich mich locals() ???
Ich habe das auch mal so gehabt und fand das, um ehrlich zu sein, recht lustig. Ist so eine kleine Python-Spielerei, die diese Sprache ermöglicht.
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Gast

Dienstag 5. Juli 2005, 18:55

hallo zusammen,

hier ist update 3

alles läuft jetzt auf der idee von tabellars tablewrapper, und einem entsprechenden dbapi.

ich habe nur mysql getest.

zuerst das mysqlDAO, das mir auf grund der vielen codewiederholungen noch nicht gefällt, v.a. muss man gucken, ob das nun dem db-api 2.0 entspricht, bez. des execute usw.
änderungen diesbez. sollten allerdings eine kleinigkeit sein. glaube ich :D
die namen der attribute möchte ich gern bis zum abschluss der zusammenarbeit beibehalten.

Code: Alles auswählen

#!/usr/bin/env python

import MySQLdb
from _mysql_exceptions import *


class MySqlDAO:
    

    def __init__(self):
        """..."""


    def connect(self,host,user,db,passwd=''):

        self.db=db
        
        try:
            self.conn=MySQLdb.connect(host=host,
                                      user=user,
                                      db=db,
                                      passwd=passwd)
             
        except OperationalError, msg:
            print msg[1]


    def getTableNameList(self):
        
        cur=self.conn.cursor()
        cur.execute("show tables from %s"%self.db)
        result=cur.fetchall()
        tableNameList=[]
        for i in result:
            tableNameList.append(i[0])
        return tableNameList    
            

    def getTableColumnsList(self,db_table,option):
        
        cur=self.conn.cursor()
        cur.execute("show columns from %s"%db_table)
        result=cur.fetchall()
        tableColList=[]
        if option==1:
            for i in result:
                if 'auto_increment' not in i:
                    tableColList.append(i[0])
        else:
            for i in result:
                tableColList.append(i[0])
        return tableColList
     
    
    def getTableColumnsData(self,s_cols_names,db_table):
     
        cursor=self.conn.cursor()
        cursor.execute("select %s from %s"%(s_cols_names,db_table))
        result=cursor.fetchall()
        cursor.close()
        return result


    def getTableColumnsDataSort(self,s_cols_names,db_table,choice):

        cursor=self.conn.cursor()
        cursor.execute("select %s from %s order by %s"%(s_cols_names,db_table,choice))
        result=cursor.fetchall()
        cursor.close()
        return result


    def getTableColumnsDataSelect(self,db_table,target):

        cursor=self.conn.cursor()
        cursor.execute("select * from %s where %s"%(db_table,target))
        result=cursor.fetchall()
        cursor.close()
        return result


    def getTableColumnsDataSearch(self,s_cols_names,db_table,choice,entry):

        cursor=self.conn.cursor()
        cursor.execute("select %s from %s where %s= '%s'"%(s_cols_names,db_table,choice,entry))
        result=cursor.fetchall()
        cursor.close()
        return result
        
        
    def delTableColumnsData(self,db_table,db_table_cols,check):

        cursor=self.conn.cursor()
        cursor.execute("delete from %s where %s = %s"%(db_table,db_table_cols,check))
        result=cursor.fetchall()
        cursor.close()
        return result
    

    def insertTableColumnsData(self,db_table,s_cols_names,entries):

        cursor=self.conn.cursor()
        cursor.execute("insert into %s (%s) values (%s)"%(db_table,s_cols_names,entries))
        result=cursor.fetchall()
        cursor.close()
        

    def updateTableColumnsData(self,db_table,result,db_table_col,check):

        cursor=self.conn.cursor()
        cursor.execute("update %s set %s where %s=%s"%(db_table,result,db_table_col,check))
        result=cursor.fetchall()
        cursor.close()
 

    def close(self):
        
        self.conn.close()
nun die neue fassung des tableWrapper moduls

Code: Alles auswählen

#!/usr/bin/env python
#Modul tableWrapper


class TableWrapper:
    """dbwrapper"""
    def __init__(self):
        """init"""

    def connect(self,DbType,Host,User,Db,Passwd):

        if DbType=='PgSQL':
           import pgsqlDAO
           self.dbWrapper=pgsqlDAO.PgSqlDAO()
           self.dbWrapper.connect(Host,Db,User)

        if DbType=='MySQL':
           import mysqlDAO
           self.dbWrapper=mysqlDAO.MySqlDAO()
           self.dbWrapper.connect(Host,User,Db,Passwd)

        if DbType=='XML':
           import xmlDAO
           self.dbWrapper=xmlDAO.XmlDAO()
           
    def getTableNameList(self):
        return self.dbWrapper.getTableNameList()

    def getTableColumnsList(self,db_table,option):
        return self.dbWrapper.getTableColumnsList(db_table,option)
   
    def getTableColumnsData(self,s_cols_names,db_table):
        return self.dbWrapper.getTableColumnsData(s_cols_names,db_table)

    def getTableColumnsDataSort(self,s_cols_names,db_table,choice):
        return self.dbWrapper.getTableColumnsDataSort(s_cols_names,db_table,choice)

    def getTableColumnsDataSelect(self,db_table,target):
        return self.dbWrapper.getTableColumnsDataSelect(db_table,target)

    def getTableColumnsDataSearch(self,s_cols_names,db_table,choice,entry):
        return self.dbWrapper.getTableColumnsDataSearch(s_cols_names,db_table,choice,entry)

    def delTableColumnsData(self,db_table,db_table_cols,check):
        return self.dbWrapper.delTableColumnsData(db_table,db_table_cols,check)

    def insertTableColumnsData(self,db_table,s_cols_names,entries):
        self.dbWrapper.insertTableColumnsData(db_table,s_cols_names,entries)

    def updateTableColumnsData(self,db_table,result,db_table_col,check):
        self.dbWrapper.updateTableColumnsData(db_table,result,db_table_col,check)        
       
    def close(self):
        self.dbWrapper.close() 
nun der client,...übrigens es ist bereits die fassung, in der tabellen ausgewählt werden können. achtung, bis auf eine ausnahme, legen sich alle fenster noch auf die selbe position am bildschirm, auch das auswahlfenster mit dem hauptfenster, also einfach drunter gucken, :D

beim test mit einer mysql datenbank mit 2 tabellen, gab es keine probleme.

Code: Alles auswählen

#!/usr/bin/env python


from Tkinter import*
from ScrolledText import*
import tkMessageBox
import sys
import tableWrapper

    

               
class Fenster:


    #Abstand der Elemente
    a_x=5 #Abstand horizontal
    a_y=5 #Abstand vertikal

    #Die Buttons bekommen alle dieselbe Breite
    b=20

    #Farbe wird auch von la verwendet
    f="#00ff00"

    lt=""

   
    def __init__(self):

        raise NotImplementedError("Abstract class")

   
    def prepare(self):

        self.root.resizable(0,0)

        self.root.protocol("WM_DELETE_WINDOW",self.mainexit)

        la=Label(self.root,bg=self.f,text="///GARO_GUI")
        la.grid(row=0,column=0,
                columnspan=2,
                padx=self.a_x,pady=self.a_y)
     
        la_1=Label(self.root,bg=self.f,text=self.lt)
        la_1.grid(row=1,column=0,
                  columnspan=2,
                  padx=self.a_x,pady=self.a_y)
       
        button=Button(self.root,
                      text="Prog. Beenden",
                      width=10,command=self.ende)
        button.grid(row=15,column=0,
                    columnspan=2,
                    padx=10,pady=10)


    def ende(self):

        antwort=tkMessageBox.askyesno\
                 ("Warnung","Sicher beenden?")
        if antwort==1:
            sys.exit(0)


    def mainexit(self):
       
        self.root.withdraw()


        

class AuswahlFenster(Fenster):

    lt="Auswahl"


    def __init__(self,hf,root,tablewrapper,db_tables):

        self.hf=hf

        self.root=Toplevel(root)
                
        self.root.title("Auswahlfenster")

        self.prepare()

        self.tablewrapper=tablewrapper

        scb_v=Scrollbar(self.root, orient="vertical")
        scb_h=Scrollbar(self.root, orient="horizontal")

        self.li_1=Listbox(self.root,
                          width=20,height=8,
                          yscrollcommand=scb_v.set,
                          xscrollcommand=scb_h.set)
       
        scb_v["command"]=self.li_1.yview
        scb_h["command"]=self.li_1.xview
       
        self.li_1.grid(row=2,column=0,
                       columnspan=2,
                       padx=self.a_x,pady=self.a_y)
       
        scb_v.grid(row=2,column=2,
                   padx=self.a_x,pady=self.a_y)
       
        scb_h.grid(row=3,column=0,
                   columnspan=2,
                   padx=self.a_x,pady=self.a_y)
                       

        b_1=Button(self.root,width=self.b,text="Auswahl",
                   command=lambda:
                   self.change_table(table=self.get_selected()))

        b_1.grid(row=4,column=0,
                 padx=self.a_x,pady=self.a_y)

        for table in db_tables:
            self.li_1.insert("end",table)
           

    def get_selected(self):

        selected=self.li_1.get("active")
        return selected


    def change_table(self,table):

        for inst in EingabeFenster.instancelist:
            inst.root.destroy()

        for inst in SuchFenster.instancelist:
            inst.root.destroy()

        hf.db_table=table

        hf.cols_names=self.tablewrapper.getTableColumnsList(hf.db_table,option=1)
        
        hf.li_1width=len(hf.cols_names)*12

        hf.s_cols_names=", ".join(hf.cols_names)

        for widget in hf.frame_1.winfo_children():
            widget.destroy()

        hf.set_frame_1()
        
        for widget in hf.frame_3.winfo_children():
            widget.destroy()

        hf.set_frame_3()

   

 
class HauptFenster(Fenster):

    lt="Ausgabe"

       
    def __init__(self):

        self.root=Tk()

        self.root.wm_geometry('+20+20')

        self.root.title("Hauptfenster")

        self.prepare()

        self.choice=StringVar()

        self.tablewrapper=tableWrapper.TableWrapper()

        self.tablewrapper.connect('MySQL','ein_host','ein_user','eine_db','ein_pw')
        
        self.db_tables=self.tablewrapper.getTableNameList()
        
        if len(self.db_tables)>1:
            auswahl=AuswahlFenster(self,self.root,self.tablewrapper,self.db_tables)
            print self.db_tables
            
        self.db_table=self.db_tables[0]
        
        self.cols_names=self.tablewrapper.getTableColumnsList(self.db_table,option=1)

        self.s_cols_names=", ".join(self.cols_names)

        self.li_1width=len(self.cols_names)*12
        
        self.frame_1=Frame(self.root)
        self.frame_1.grid(row=2,column=0,columnspan=2)
        self.set_frame_1()

        self.frame_2=Frame(self.root)
        self.frame_2.grid(row=5,column=0,columnspan=2)
        self.set_frame_2()

        self.frame_3=Frame(self.root)
        self.frame_3.grid(row=9,column=1)
        self.set_frame_3()


    def set_frame_1(self):

        self.scb_v=Scrollbar(self.frame_1, orient="vertical")
        self.scb_h=Scrollbar(self.frame_1, orient="horizontal")

        self.li_1=Listbox(self.frame_1,
                          width=self.li_1width,height=8,
                          yscrollcommand=self.scb_v.set,
                          xscrollcommand=self.scb_h.set)

      
        self.scb_v["command"]=self.li_1.yview
        self.scb_h["command"]=self.li_1.xview
       
        self.li_1.grid(row=3,column=0,
                       columnspan=2,
                       padx=self.a_x,pady=self.a_y)
       
        self.scb_v.grid(row=3,column=2,
                        padx=self.a_x,pady=self.a_y)
       
        self.scb_h.grid(row=4,column=0,
                        columnspan=2,
                        padx=self.a_x,pady=self.a_y)

                
    def set_frame_2(self):
        
        b_1=Button(self.frame_2,width=self.b,text="Alle Daten",
                   command=lambda:
                   self.list_data
                   (result=self.tablewrapper.getTableColumnsData(self.s_cols_names,self.db_table)))
        b_1.grid(row=6,column=0,
                 padx=self.a_x,pady=self.a_y)

        b_2=Button(self.frame_2,width=self.b,
                   text="Loeschen",command=self.ask)
        b_2.grid(row=6,column=1,
                 padx=self.a_x,pady=self.a_y)

        b_3=Button(self.frame_2,width=self.b,text="Sortieren",
                   command=lambda:
                   self.list_data(result=self.tablewrapper.getTableColumnsDataSort(self.s_cols_names,
                                                                                   self.db_table,
                                                                                   self.choice.get())))
        b_3.grid(row=7,column=0,
                 padx=self.a_x,pady=self.a_y)      

        b_4=Button(self.frame_2,width=self.b,text="Eingabe",
                   command=lambda:
                   EingabeFenster
                   (self.frame_2,self.tablewrapper,
                    self.db_table,self.cols_names,
                    self.root.winfo_width()))
        b_4.grid(row=7,column=1,
                 padx=self.a_x,pady=self.a_y)
        
        b_5=Button(self.frame_2,width=self.b,text="Suchen",
                   command=lambda:
                   SuchFenster
                   (self,self.root,self.db_table))        
        b_5.grid(row=8,column=0,
                 padx=self.a_x,pady=self.a_y)

        b_6=Button(self.frame_2,width=self.b,text="Bearbeiten",
                   command=lambda:
                   BearbeitungsFenster
                   (self.root,self.tablewrapper,
                    self.db_table,self.cols_names,
                    self.li_1.get("active"),
                    self.root.winfo_width()))
        b_6.grid(row=8,column=1,padx=self.a_x,pady=self.a_y)

        
    def set_frame_3(self):

        for i in range(len(self.cols_names)):

            self.rb=Radiobutton(self.frame_3,text=self.cols_names[i],
                        value=self.cols_names[i],
                        variable=self.choice)
            self.rb.grid(row=i+9,column=1,
                         padx=self.a_x,pady=self.a_y)
         

            if i==0:
                self.rb.select()
                
        self.list_data(result=self.tablewrapper.getTableColumnsData(self.s_cols_names,self.db_table))


    def list_data(self,result):
       
        self.li_1.delete(0,END)
       
        result=[list(element) for element in result]

        for element in result:
            for i in range(len(element)):
                element[i]=str(element[i])
               
        result=["   ".join(element) for element in result]

        for elements in result:
                self.li_1.insert("end",elements)         

           
    def get_selected(self):

        selected=self.li_1.get("active")
        selected=selected.split()
        selected=[str(selected[i]).replace(str(selected[i]),'"'+str(selected[i])+'"')
                     for i in range(len(selected))]
                     
        target=[self.cols_names[i]+"="+selected[i]
                       for i in range(len(selected))]
        target=" and ".join(target)

        check=self.tablewrapper.getTableColumnsDataSelect(self.db_table,target)        
        check=check[0][0]

        db_table_cols=self.tablewrapper.getTableColumnsList(self.db_table,option=0)

        self.tablewrapper.delTableColumnsData(self.db_table,db_table_cols[0],check)

   
    def ask(self):

        answer=tkMessageBox.askyesno("Warnung",
                                     "Wollen Sie den gewaehlten Datensatz sicher loeschen ?")
        if answer==1:
            self.get_selected()
     
         
        else:
            pass

           

       
class EingabeFenster(Fenster):

    lt="Eingabe/Bearbeitung"
    instancelist=[]

   
    def __init__(self,root,tablewrapper,db_table,cols_names,hfwidth):


        self.root=Toplevel(root)

        self.root.wm_geometry('%s+20'%('+'+str(hfwidth+40)))

        self.root.title("Eingabefenster")
     
        self.prepare()
        
        self.tablewrapper=tablewrapper
   
        self.db_table=db_table

        self.cols_names=cols_names

        self.s_cols_names=", ".join(self.cols_names)

        self.entrylist=[]

        for i in range(len(self.cols_names)):
           
            la=Label(self.root,
                          text=self.cols_names[i])
            la.grid(row=i+2,column=0)

            entry=Entry(self.root)
            entry.grid(row=i+2,column=1,
                       padx=self.a_x,pady=self.a_y)
            self.entrylist.append(entry)

        b_1=Button(self.root,width=self.b,
                   text="Eintragen",
                   command=lambda:
                   self.get_entries())                       
        b_1.grid(row=10,column=1,
                 columnspan=2,
                 padx=self.a_x,pady=self.a_y)

        EingabeFenster.instancelist.append(self)

       
    def get_entries(self):

        entries=[element.get() for element in self.entrylist]
       
        for i in range(len(entries)):
            test=entries[i].find(" ")
            if test and test !=-1:
                entries[i]=entries[i].replace(entries[i][test],"/")
               
        for element in self.entrylist: element.delete(0,"end")
       
        entries=[entries[i].replace(entries[i],'"'+entries[i]+'"')
                      for i in range(len(entries))]

        s_entries=", ".join(entries)

        self.tablewrapper.insertTableColumnsData(self.db_table,self.s_cols_names,s_entries)   
    



class BearbeitungsFenster(Fenster,EingabeFenster):

    lt="Bearbeitung"
   

    def __init__(self,root,tablewrapper,db_table,cols_names,selected,hfwidth):
       
        self.selected=selected
        self.selected=self.selected.split()
        self.cols_names=cols_names

        EingabeFenster.__init__(self,root,tablewrapper,db_table,cols_names,hfwidth)
       
        self.root.title("Bearbeitungsfenster")

        for i in range(len(self.entrylist)):
            self.entrylist[i].insert(0,self.selected[i])

        b_1=Button(self.root,width=self.b,
                   text="Eintragen",
                   command=lambda:
                   self.get_entries())                       
        b_1.grid(row=10,column=1,
                 columnspan=2,
                 padx=self.a_x,pady=self.a_y)
       
   
    def get_entries(self):

        entries=[element.get() for element in self.entrylist]
       
        for i in range(len(entries)):
            test=entries[i].find(" ")
            if test and test !=-1:
                entries[i]=entries[i].replace(entries[i][test],"/")
               
        for element in self.entrylist: element.delete(0,"end")
       
        entries=[entries[i].replace(entries[i],'"'+entries[i]+'"')
                      for i in range(len(entries))]


        s_entries=", ".join(entries)

        result=[self.cols_names[i]+"="+entries[i]
                for i in range(len(entries))]
        result=", ".join(result)

        self.selected=list(self.selected)
        self.selected=[str(self.selected[i]).replace(str(self.selected[i]),'"'+str(self.selected[i])+'"')
                       for i in range(len(self.selected))]
       
        target=[self.cols_names[i]+"="+self.selected[i]
                for i in range(len(self.selected))]
        target=" and ".join(target)

        check=self.tablewrapper.getTableColumnsDataSelect(self.db_table,target)        
        check=check[0][0]

        db_table_cols=self.tablewrapper.getTableColumnsList(self.db_table,option=0)

        self.tablewrapper.updateTableColumnsData(self.db_table,result,db_table_cols[0],check)

       

                   
class SuchFenster(Fenster):

    lt="Suche"
    instancelist=[]


    def __init__(self,hf,root,db_table):

        self.root=Toplevel(root)

        self.root.title("Suchfenster")

        self.prepare()
       
        choice=StringVar() 
    
        self.db_table=db_table

        entry=Entry(self.root)
        entry.grid(row=3,column=0)

        for i in range(len(hf.cols_names)):

            rb=Radiobutton(self.root,text=hf.cols_names[i],
                           value=hf.cols_names[i],
                           variable=choice)
            rb.grid(row=i+2,column=1,
                         padx=self.a_x,pady=self.a_y)

            if i==0:
                rb.select()           

        b_1=Button(self.root,text="Suche",
                   command=lambda:
                   hf.list_data
                   (result=hf.tablewrapper.getTableColumnsDataSearch
                   (hf.s_cols_names,self.db_table,choice.get(),entry.get())))                       
        b_1.grid(row=9,column=0)

        SuchFenster.instancelist.append(self)




if __name__ == "__main__":

    hf=HauptFenster()

    mainloop() 
liebe grüße

rolgal
tabellar
User
Beiträge: 186
Registriert: Mittwoch 4. September 2002, 15:28

Dienstag 5. Juli 2005, 20:33

rolgal hat geschrieben:hallo zusammen,

hier ist update 3

alles läuft jetzt auf der idee von tabellars tablewrapper, und einem entsprechenden dbapi.

ich habe nur mysql getest.
...
Hi rolgal,

super, dass du weiter gemacht hast :shock: !!! Ich hab auf die Schnelle die Anpassungen gemacht und es hat dann mit PostgreSQL gleich funktioniert (Tabellenanzeige, Daten anzeigen...) :P . Das "option" Argument bzgl. der "Autoincrement, Serial, etc. " Spaltenauswahl finde ich übrigens sehr gut. Ich werde jetzt dann peu à peu das pgsqlDAO und das xmlDAO Modul anpassen, damit dann auch alles funktioniert. Das ist doch jetzt wirklich genial, dass wir durch die "kleine Programmänderung" :wink: eine saubere Schnittstelle zwischen DB-Client und der DB haben...Da wird das weitere GUI Designen dann immer einfacher...

Gruss Tabellar
Gast

Sonntag 16. Oktober 2005, 18:05

hallo zusammen,

hier kommt update 4,

die fenster ordnen sich sinnvoller an, es gibt abhängigkeiten, d.h. wird eine datenbank mit nur einer tabelle geladen, baut sich das hauptfenster weiter links auf als wenn das auswahlfenster aufgebaut wird, dann plaziert sich das hauptfenster nämlich rechts neben dem auswahlfenster.

dann habe ich nach blackjacks ohrwaschelrennen :P einige list compr. und for schleifen entrümpelt, sicherlich gibts noch einigen codemüll den keiner braucht, wer etwas findet wird mit meiner dankbarkeit belohnt :D


tablewrapper und mysqldao blieben unverändert.

Code: Alles auswählen

#!C:\Python24\python.exe


from Tkinter import*
from ScrolledText import*
import tkMessageBox
import sys
import tableWrapper

    

               
class Fenster:


    #Abstand der Elemente
    a_x=5 #Abstand horizontal
    a_y=5 #Abstand vertikal

    #Die Buttons bekommen alle dieselbe Breite
    b=20

    #Farbe wird auch von la verwendet
    f="#00ff00"

    lt=""

   
    def __init__(self):

        raise NotImplementedError("Abstract class")

   
    def prepare(self):

        self.root.resizable(0,0)

        self.root.protocol("WM_DELETE_WINDOW",self.mainexit)

        la=Label(self.root,bg=self.f,text="///GARO_GUI")
        la.grid(row=0,column=0,
                columnspan=2,
                padx=self.a_x,pady=self.a_y)
     
        la_1=Label(self.root,bg=self.f,text=self.lt)
        la_1.grid(row=1,column=0,
                  columnspan=2,
                  padx=self.a_x,pady=self.a_y)
       
        button=Button(self.root,
                      text="Prog. Beenden",
                      width=10,command=self.ende)
        button.grid(row=15,column=0,
                    columnspan=2,
                    padx=10,pady=10)


    def ende(self):

        antwort=tkMessageBox.askyesno\
                 ("Warnung","Sicher beenden?")
        if antwort==1:
            sys.exit(0)


    def mainexit(self):
       
        self.root.withdraw()


        

class AuswahlFenster(Fenster):

    lt="Auswahl"


    def __init__(self,hf,root,tablewrapper,db_tables):

        self.hf=hf

        self.root=Toplevel(root)
        
        self.root.wm_geometry('+20+20')
                
        self.root.title("Auswahlfenster")

        self.prepare()

        self.tablewrapper=tablewrapper

        scb_v=Scrollbar(self.root, orient="vertical")
        scb_h=Scrollbar(self.root, orient="horizontal")

        self.li_1=Listbox(self.root,
                          width=20,height=8,
                          yscrollcommand=scb_v.set,
                          xscrollcommand=scb_h.set)
       
        scb_v["command"]=self.li_1.yview
        scb_h["command"]=self.li_1.xview
       
        self.li_1.grid(row=2,column=0,
                       columnspan=2,
                       padx=self.a_x,pady=self.a_y)
       
        scb_v.grid(row=2,column=2,
                   padx=self.a_x,pady=self.a_y)
       
        scb_h.grid(row=3,column=0,
                   columnspan=2,
                   padx=self.a_x,pady=self.a_y)
                       

        b_1=Button(self.root,width=self.b,text="Auswahl",
                   command=lambda:
                   self.change_table(table=self.get_selected()))


        b_1.grid(row=4,column=0,
                 padx=self.a_x,pady=self.a_y)

        for table in db_tables:
            self.li_1.insert("end",table)
           

    def get_selected(self):

        selected=self.li_1.get("active")
        return selected


    def change_table(self,table):

        for inst in EingabeFenster.instancelist:
            inst.root.destroy()

        for inst in SuchFenster.instancelist:
            inst.root.destroy()

        hf.db_table=table

        hf.cols_names=self.tablewrapper.getTableColumnsList(hf.db_table,option=1)
        
        hf.li_1width=len(hf.cols_names)*12

        hf.s_cols_names=", ".join(hf.cols_names)

        for widget in hf.frame_1.winfo_children():
            widget.destroy()

        hf.set_frame_1()
        
        for widget in hf.frame_3.winfo_children():
            widget.destroy()

        hf.set_frame_3()

   

 
class HauptFenster(Fenster):

    lt="Ausgabe"

       
    def __init__(self):
        

        self.tablewrapper=tableWrapper.TableWrapper()

        self.tablewrapper.connect('MySQL','localhost','rolgal','eine_datenbank','ein_passwort')
        
        self.db_tables=self.tablewrapper.getTableNameList()

        self.root=Tk()
                
        if len(self.db_tables)>1:
            auswahl=AuswahlFenster(self,self.root,self.tablewrapper,self.db_tables)             

        try:
            auswahl
            auswahl.root.update()
            self.root.wm_geometry('+%s+20'%(str(auswahl.root.winfo_width()+30)))
            
        except NameError:
            self.root.wm_geometry('+20+20')


        self.root.title("Hauptfenster")

        self.prepare()

        self.choice=StringVar()
            
        self.db_table=self.db_tables[0]
        
        self.cols_names=self.tablewrapper.getTableColumnsList(self.db_table,option=1)

        self.s_cols_names=", ".join(self.cols_names)

        self.li_1width=len(self.cols_names)*12
        
        self.frame_1=Frame(self.root)
        self.frame_1.grid(row=2,column=0,columnspan=2)
        self.set_frame_1()

        self.frame_2=Frame(self.root)
        self.frame_2.grid(row=5,column=0,columnspan=2)
        self.set_frame_2()

        self.frame_3=Frame(self.root)
        self.frame_3.grid(row=9,column=1)
        self.set_frame_3()


    def set_frame_1(self):

        self.scb_v=Scrollbar(self.frame_1, orient="vertical")
        self.scb_h=Scrollbar(self.frame_1, orient="horizontal")

        self.li_1=Listbox(self.frame_1,
                          width=self.li_1width,height=8,
                          yscrollcommand=self.scb_v.set,
                          xscrollcommand=self.scb_h.set)
      
        self.scb_v["command"]=self.li_1.yview
        self.scb_h["command"]=self.li_1.xview
       
        self.li_1.grid(row=3,column=0,
                       columnspan=2,
                       padx=self.a_x,pady=self.a_y)
       
        self.scb_v.grid(row=3,column=2,
                        padx=self.a_x,pady=self.a_y)
       
        self.scb_h.grid(row=4,column=0,
                        columnspan=2,
                        padx=self.a_x,pady=self.a_y)

                
    def set_frame_2(self):
        
        b_1=Button(self.frame_2,width=self.b,text="Alle Daten",
                   command=lambda:
                   self.list_data
                   (result=self.tablewrapper.getTableColumnsData(self.s_cols_names,self.db_table)))
        b_1.grid(row=6,column=0,
                 padx=self.a_x,pady=self.a_y)

        b_2=Button(self.frame_2,width=self.b,
                   text="Loeschen",command=self.ask)
        b_2.grid(row=6,column=1,
                 padx=self.a_x,pady=self.a_y)

        b_3=Button(self.frame_2,width=self.b,text="Sortieren",
                   command=lambda:
                   self.list_data
                   (result=self.tablewrapper.getTableColumnsDataSort(self.s_cols_names,self.db_table,self.choice.get())))
        b_3.grid(row=7,column=0,
                 padx=self.a_x,pady=self.a_y)      

        b_4=Button(self.frame_2,width=self.b,text="Eingabe",
                   command=lambda:
                   EingabeFenster
                   (self))
        b_4.grid(row=7,column=1,
                 padx=self.a_x,pady=self.a_y)
        
        b_5=Button(self.frame_2,width=self.b,text="Suchen",
                   command=lambda:
                   SuchFenster
                   (self))        
        b_5.grid(row=8,column=0,
                 padx=self.a_x,pady=self.a_y)

        b_6=Button(self.frame_2,width=self.b,text="Bearbeiten",
                   command=lambda:
                   BearbeitungsFenster
                   (self))
        b_6.grid(row=8,column=1,padx=self.a_x,pady=self.a_y)

        
    def set_frame_3(self):

        for i in range(len(self.cols_names)):

            self.rb=Radiobutton(self.frame_3,text=self.cols_names[i],
                        value=self.cols_names[i],
                        variable=self.choice)
            self.rb.grid(row=i+9,column=1,
                         padx=self.a_x,pady=self.a_y)
            if i==0:
                self.rb.select()
                
        self.list_data(result=self.tablewrapper.getTableColumnsData(self.s_cols_names,self.db_table))


    def list_data(self,result):
       
        self.li_1.delete(0,END)
       
        result=[list(element) for element in result]

        for element in result:
            for i in range(len(element)):
                element[i]=str(element[i])
            
        result=["   ".join(element) for element in result]

        for elements in result:
                self.li_1.insert("end",elements)         

           
    def get_selected(self):

        selected=self.li_1.get("active")
     
        selected=['"'+str(select)+'"' for select in selected.split()]
         
        target=[self.cols_names[i]+"="+selected[i]
                       for i in range(len(selected))]
       
        target=" and ".join(target)
              
        check=self.tablewrapper.getTableColumnsDataSelect(self.db_table,target)
        
        check=check[0][0]
        
        db_table_cols=self.tablewrapper.getTableColumnsList(self.db_table,option=0)

        self.tablewrapper.delTableColumnsData(self.db_table,db_table_cols[0],check)
        self.list_data(result=self.tablewrapper.getTableColumnsData(self.s_cols_names,self.db_table))

   
    def ask(self):

        answer=tkMessageBox.askyesno("Warnung",
                                     "Wollen Sie den gewaehlten Datensatz sicher loeschen ?")
        if answer==1:
            self.get_selected()


           
       
class EingabeFenster(Fenster):

    lt="Eingabe/Bearbeitung"
    instancelist=[]

   
    def __init__(self,hf):

        self.root=Toplevel(hf.root)

        self.root.wm_geometry('+%s+20'%(str(hf.root.winfo_rootx()+hf.root.winfo_width()+20)))

        self.root.title("Eingabefenster")
     
        self.prepare()

        self.entrylist=[]

        for i in range(len(hf.cols_names)):
           
            la=Label(self.root,
                          text=hf.cols_names[i])
            la.grid(row=i+2,column=0)

            entry=Entry(self.root)
            entry.grid(row=i+2,column=1,
                       padx=self.a_x,pady=self.a_y)
            self.entrylist.append(entry)

        b_1=Button(self.root,width=self.b,
                   text="Eintragen",
                   command=lambda:
                   self.get_entries())                       
        b_1.grid(row=10,column=1,
                 columnspan=2,
                 padx=self.a_x,pady=self.a_y)

        EingabeFenster.instancelist.append(self)

       
    def get_entries(self):

        entries=[element.get() for element in self.entrylist]
         
        for element in self.entrylist: element.delete(0,"end")
                   
        entries = ['"' + entry.replace(' ', '/') + '"' for entry in entries]
  
        s_entries=", ".join(entries)
        s_entries.replace('""', 'None')
        
        hf.tablewrapper.insertTableColumnsData(hf.db_table,hf.s_cols_names,s_entries)
        hf.list_data(result=hf.tablewrapper.getTableColumnsData(hf.s_cols_names,hf.db_table))
    



class BearbeitungsFenster(Fenster,EingabeFenster):

    lt="Bearbeitung"
   

    def __init__(self,hf):
       
        self.selected=hf.li_1.get("active")
        self.selected=self.selected.split()

        EingabeFenster.__init__(self,hf)
       
        self.root.title("Bearbeitungsfenster")

        for i in range(len(self.entrylist)):
            self.entrylist[i].insert(0,self.selected[i])

        b_1=Button(self.root,width=self.b,
                   text="Eintragen",
                   command=lambda:
                   self.get_entries())                       
        b_1.grid(row=10,column=1,
                 columnspan=2,
                 padx=self.a_x,pady=self.a_y)
       
   
    def get_entries(self):

        entries=[element.get() for element in self.entrylist]
        
        for element in self.entrylist: element.delete(0,"end")
        
        entries = ['"' + entry.replace(' ', '/') + '"' for entry in entries]       
        s_entries=", ".join(entries)        

        result=[hf.cols_names[i]+"="+entries[i]
                for i in range(len(entries))]     
        result=", ".join(result)        
      
        self.selected=['"'+str(select)+'"' for select in self.selected]
     
        target=[hf.cols_names[i]+"="+self.selected[i]
                for i in range(len(self.selected))]   
        target=" and ".join(target) 

        check=hf.tablewrapper.getTableColumnsDataSelect(hf.db_table,target)        
        check=check[0][0]

        db_table_cols=hf.tablewrapper.getTableColumnsList(hf.db_table,option=0)        

        hf.tablewrapper.updateTableColumnsData(hf.db_table,result,db_table_cols[0],check)
        hf.list_data(result=hf.tablewrapper.getTableColumnsData(hf.s_cols_names,hf.db_table))

       

                   
class SuchFenster(Fenster):

    lt="Suche"
    instancelist=[]


    def __init__(self,hf):

        self.root=Toplevel(hf.root)

        self.root.wm_geometry('+%s+20'%(str(hf.root.winfo_rootx()+hf.root.winfo_width()+20)))

        self.root.title("Suchfenster")

        self.prepare()
       
        choice=StringVar() 

        entry=Entry(self.root)
        entry.grid(row=3,column=0)

        for i in range(len(hf.cols_names)):

            rb=Radiobutton(self.root,text=hf.cols_names[i],
                           value=hf.cols_names[i],
                           variable=choice)
            rb.grid(row=i+2,column=1,
                         padx=self.a_x,pady=self.a_y)

            if i==0:
                rb.select()           

        b_1=Button(self.root,text="Suche",
                   command=lambda:
                   hf.list_data
                   (result=hf.tablewrapper.getTableColumnsDataSearch
                   (hf.s_cols_names,hf.db_table,choice.get(),entry.get())))                       
        b_1.grid(row=9,column=0)

        SuchFenster.instancelist.append(self)




if __name__ == "__main__":

    hf=HauptFenster()

    mainloop() 
grüße rolgal
Zuletzt geändert von Gast am Sonntag 16. Oktober 2005, 18:10, insgesamt 2-mal geändert.
Antworten