def dbinsert(database, dbclassname, rows, colnames):
dbclass = dbtblfactory(dbclassname)
for x in range(len(rows)):
dm = {}
emptyrow = True
for y in range(len(colnames)):
colname = colnames[y]
value = rows[x][y]
if colname <> "" and colname.startswith("_") == False:
if value <> "":
dm[colname] = value
emptyrow = False
if emptyrow == False:
dbobj = dbclass.datamembers(database=database, dm=dm)
with database:
try:
exec_str, result = dbobj.persist()
log.log(thisfuncname(),
4,
func=dbobj.persist,
exec_str=exec_str,
result=result)
except Exception, e:
log.log(thisfuncname(),
1,
func=dbobj.persist,
error=str(e))
def insert(self,database=None):
if database==None:
database = Database(self.dbname_entry_sv.get())
dbclass = dbtblfactory(self.tblname_entry_sv.get())
for x in range(1,self.maxnewrows):
dm={}
emptyrow=True
for y in range(self.maxcols):
colname = self.newrowgrid.widgets[0][y].sv.get()
value = self.newrowgrid.widgets[x][y].sv.get()
if colname <> "" and colname.startswith("_") == False:
if value <> "":
dm[colname] = value
emptyrow=False
if emptyrow == False:
dbobj = dbclass.datamembers(database=database,dm=dm)
with database:
try:
exec_str,result = dbobj.persist()
log.log(thisfuncname(),4,func=dbobj.persist,exec_str=exec_str,result=result)
except Exception, e:
log.log(thisfuncname(),1,func=dbobj.persist,error=str(e))
def lesson_change(self, lesson):
period = lesson.period.objid
student = lesson.student.objid
# add the lesson to the teacher object
teacher = lesson.teacher
if hasattr(teacher, 'lessons') == False:
setattr(teacher, 'lessons', {})
if teacher.lessons.has_key(period) == False:
teacher.lessons[period] = []
teacher.lessons[period].append(lesson)
log.log(thisfuncname(),
9,
msg="lesson added to teacher",
lesson=lesson)
# add the lesson to the student object
student = lesson.student
if hasattr(student, 'lessons') == False:
setattr(student, 'lessons', {})
if student.lessons.has_key(period) == False:
student.lessons[period] = []
student.lessons[period].append(lesson)
log.log(thisfuncname(),
9,
msg="lesson added to student",
lesson=lesson)
def insert(self,database=None):
if database==None:
database = Database(self.dbname_entry_sv.get())
dbclass = dbtblfactory(self.tblname_entry_sv.get())
for x in range(1,self.maxnewrows):
dm={}
emptyrow=True
for y in range(self.maxcols):
colname = self.newrowgrid.widgets[0][y].sv.get()
value = self.newrowgrid.widgets[x][y].sv.get()
if colname <> "" and colname.startswith("_") == False:
if value <> "":
dm[colname] = value
emptyrow=False
if emptyrow == False:
dbobj = dbclass.datamembers(database=database,dm=dm)
with database:
try:
exec_str,result = dbobj.persist()
log.log(thisfuncname(),4,func=dbobj.persist,exec_str=exec_str,result=result)
except Exception, e:
log.log(thisfuncname(),1,func=dbobj.persist,error=str(e))
def dbbulkloader(database, dbrecords, tblname, cols, maxsize=300):
with database:
dbcoldefn = _gencoldefn(dbrecords[0], cols)
if not tbl_exists(database, tblname) == True:
tbl_create(database, tblname, dbcoldefn)
dbrecords = _quotestrs(dbrecords)
if len(dbrecords) > maxsize:
for starti in range(0, len(dbrecords), maxsize):
if starti + maxsize > len(dbrecords):
endi = len(dbrecords)
else:
endi = starti + maxsize
tbl_rows_insert(database, tblname, cols,
dbrecords[starti:endi])
log.log(thisfuncname(),
10,
msg="loaded rows to " + tblname,
numrow=endi - starti)
else:
tbl_rows_insert(database, tblname, cols, dbrecords)
log.log(thisfuncname(),
10,
msg="loaded rows to " + tblname,
numrow=len(dbrecords))
def lesson_change(self,lesson):
period = lesson.period.objid
student = lesson.student.objid
# add the lesson to the teacher object
teacher = lesson.teacher
if hasattr(teacher,'lessons') == False:
setattr(teacher,'lessons',{})
if teacher.lessons.has_key(period) == False:
teacher.lessons[period] = []
teacher.lessons[period].append(lesson)
log.log(thisfuncname(),9,msg="lesson added to teacher",lesson=lesson)
# add the lesson to the student object
student = lesson.student
if hasattr(student,'lessons') == False:
setattr(student,'lessons',{})
if student.lessons.has_key(period) == False:
student.lessons[period] = []
student.lessons[period].append(lesson)
log.log(thisfuncname(),9,msg="lesson added to student",lesson=lesson)
def dropdown_build(database,
widgetargs,
exec_func,
prep,
dow="Monday",
rowheaderexecfunc=None,
columnheaderexecfunc=None,
ui=None):
xoffset=0
yoffset=0
log.log(thisfuncname(),3,msg="creating dropdowns lists",dow=dow,prep=prep)
# if not creating dropdowns for the headers increment the count
if rowheaderexecfunc == None: yoffset=1
if columnheaderexecfunc == None: xoffset=1
output = []
with database:
for y in range(yoffset,len(widgetargs[0])):
colndefn,values,exec_str = exec_func(database,y,prep,dow)
# pull out distinct and make a single list
values = [value[0] for value in values]
values = list(set(values))
# add a 'values' attr for each widget
for x in range(xoffset,len(widgetargs)):
widgetargs[x][y]['values'] = values
log.log(thisfuncname(),10,msg="generated data dropdowns",num=len(values),query=exec_str)
if rowheaderexecfunc <> None:
colndefn,values,exec_str = rowheaderexecfunc(database,"prep",prep)
values = [value[0] for value in values]
for x in range(len(widgetargs)):
widgetargs[x][0]['values'] = values
if ui <> None:
ui.widgets[x][0].sv.set(values[x])
log.log(thisfuncname(),10,msg="generated row hdr dropdowns",num=len(values),query=exec_str)
if columnheaderexecfunc <> None:
colndefn,values,exec_str = columnheaderexecfunc(database)
values = [value[0] for value in values]
for y in range(len(widgetargs[0])):
widgetargs[0][y]['values'] = values
if ui <> None:
ui.widgets[0][y].sv.set(values[y])
log.log(thisfuncname(),10,msg="generated col hdr dropdowns",num=len(values),query=exec_str)
return(widgetargs)
def update_callback(ui, widget, new_value):
''' via BaseTk class; all entry widgets assign a callback to the change event
to call this function if it exists '''
#put event on here too
if str(widget.current_value) <> str(new_value):
widget.version += 1
log.log(thisfuncname(),
10,
msg="updating " + str(widget.winfo_name()),
current_value=str(widget.current_value),
new_value=new_value,
version=str(widget.version))
widget.config(foreground='red')
# record event in update log
ui.updates[str(widget.winfo_name())] = (new_value, widget.version)
else:
widget.config(foreground='black')
log.log(thisfuncname(),
9,
msg="skipping " + str(widget.winfo_name()),
current_value=str(widget.current_value),
new_value=new_value,
version=str(widget.version))
def modeset(self,event):
print self
log.log(thisfuncname(),9,msg="input mode",currentmode= self.current_inputmode,tag="clipboard")
new_inputmode = None
if event.keysym == "s":
new_inputmode = "Select"
elif event.keysym == "r":
self.selection_clear()
elif event.keysym == "c":
self.clipboard_add_selection()
elif event.keysym == "x":
self.clipboard_add_selection(cut=True)
elif event.keysym == "n":
if self.clipboard_selection == len(self.clipboard):
self.clipboard_selection = 1
else:
self.clipboard_selection+=1
self.clipboard_selected_label_sv.set(self.clipboard_selection)
log.log(thisfuncname(),9,msg="clipboard selection set",selection=self.clipboard_selection,tag="clipboard")
elif event.keysym == "v":
self.clipboard_paste()
elif event.keysym == "d":
print self.clipboard
else:
pass
if new_inputmode <> None:
#self.inputmode_label_sv.set(new_inputmode)
log.log(thisfuncname(),9,msg="input mode set",newmode=new_inputmode,tag="clipboard")
self.current_inputmode = new_inputmode
self.widgets[0][0].sv.set(new_inputmode)
def _isname(enums, objtype, value):
''' ensures that value is a name by converting from code if required '''
try:
if value in enums[objtype]['name']:
return value
except KeyError:
log.log(thisfuncname(),
2,
msg="could not lookup name",
objtype=objtype,
value=str(value))
return "??"
try:
if value in enums[objtype]['code2name'].keys():
return enums[objtype]['code2name'][value]
except KeyError:
log.log(thisfuncname(),
2,
msg="could not lookup code2name",
objtype=objtype,
value=str(value))
return "??"
try:
if value in enums[objtype]['enum2name'].keys():
return enums[objtype]['enum2name'][value]
except KeyError:
log.log(thisfuncname(),
2,
msg="could not lookup enum2name",
objtype=objtype,
value=str(value))
return "??"
def set_update_trace(self):
''' this is the default and works for any widget that has a StringVar assigned to -textvariable
otherwise you need to '''
widget_class = str(self.widget.winfo_class())
try:
self.sv.trace("w",lambda name,index,mode,sv=self.sv:
self.toplevel.update_callback(self.widget,self.sv.get()))
log.log(thisfuncname(),10,func=self.sv.trace,widgetclass=widget_class, widget=self.toplevel)
except Exception, e:
log.log(thisfuncname(),1,func=self.sv.trace,widgetclass=widget_class, widget=self.toplevel,error=str(e))
def _iscode(enums,objtype,value):
''' ensures that value is a code by converting from code if required '''
try:
if value in enums[objtype]['code2name'].keys():
return value
except KeyError:
log.log(thisfuncname(),2,msg="could not lookup code2name",objtype=objtype,value=str(value))
return "??"
try:
if value in enums[objtype]['name']:
return enums[objtype]['name2code'][value]
except KeyError:
log.log(thisfuncname(),2,msg="could not lookup name2code",objtype=objtype,value=str(value))
return "??"
def __init__(self,dbname,refdbname):
log.log(thisfuncname(),3,msg="initialize",dbname=dbname,refdbname=refdbname)
self.colorpalette = dict(wp=green,subject=lightblue,ap='yellow',
Movement=pink,ELA=salmon,Humanities=lightyellow,
Counseling=lightgreen,Math=lightturquoise,
Music=lightblue,STEM=lavender,Art=purple,History=pink,
Science=darkgreen,Core=karky,Chess=burgundy,
computertime='darkgrey',Speech=darkburgundy,
Student_News=darkgrey,Computer_Time=brown,
Activity_Period=mauve,Melissa=navyblue,Amelia=darkgreen,
Samantha=darkyellow, Alexa=paleblue, Paraic=palegreen,
Francisco=cerise,Rahul=verydarkgrey,Dylan=verydarkgrey,
Moira=verydarkgrey,Issey=verydarkgrey, Daryl=verydarkgrey,
Karolina=verydarkgrey)
self.fontpalette = dict(Amelia=green,Paraic=darkgreen,Stan=lavender,
Samantha=lightgreen,Alexa=blue,Francisco=purple,
Melissa=lightblue,Rahul=dirtyyellow,Dylan=dirtyyellow,
Moira=dirtyyellow,Issey=dirtyyellow, Daryl=dirtyyellow,
Karolina=dirtyyellow,Chess=pink,Student_News=lightyellow,
subject=blue)
self.of = ObjFactory(True)
self.refdatabase = Database(refdbname)
self.dbname = dbname
self.database = Database(self.dbname)
self.lastsaveversion=0
def persist(self):
with self.database:
for obj in self.of.object_iter():
exec_str, result = obj.persist()
log.log(thisfuncname(),9,msg="persisting of obj",objid=str(obj),exec_str=exec_str,
result=result)
def getdbenum(enums, database, fldname, tblname, **kwargs):
'''
every table has a code column which is a 2 digit unique mnemonic
given a name lookup a code
given a code lookup a name
given a code/name get an enumeration
get names, codes
'''
#database = Database(dbname)
exec_str = "select {1},code,enum from {0}".format(tblname, fldname)
where_str = ""
for key, value in kwargs.iteritems():
if where_str == "":
where_str = " where {0} = {1}".format(key, value)
else:
where_str = where_str + " and {0} = {1}".format(key, value)
exec_str = exec_str + where_str
import sqlite3
with database:
try:
coldefn, values, _ = tbl_query(database, exec_str)
except DBException, e:
log.log(thisfuncname(),
0,
exception=e,
msg=e.message,
tblname=tblname,
fldname=fldname)
def lookupenum(enums,converttype,fieldtype,code):
try:
name = enums[fieldtype][converttype][code]
except KeyError, e:
msg = "lookup failed: type={0},field ={1},code={2} [{3}]".format(converttype,fieldtype,code,e.message,enums[fieldtype])
log.log(thisfuncname(),2,msg=msg)
raise Exception(msg)
def getdbenum(enums,database,fldname,tblname,**kwargs):
'''
every table has a code column which is a 2 digit unique mnemonic
given a name lookup a code
given a code lookup a name
given a code/name get an enumeration
get names, codes
'''
#database = Database(dbname)
exec_str = "select {1},code,enum from {0}".format(tblname,fldname)
where_str = ""
for key,value in kwargs.iteritems():
if where_str == "":
where_str = " where {0} = {1}".format(key,value)
else:
where_str = where_str + " and {0} = {1}".format(key,value)
exec_str = exec_str + where_str
import sqlite3
with database:
try:
coldefn,values,_ = tbl_query(database,exec_str)
except DBException, e:
log.log(thisfuncname(),0,exception=e,msg=e.message,tblname=tblname,fldname=fldname)
def __init__(self,widget,**kwargs):
self.widget = widget
parent = self.widget.winfo_parent()
gparent = self._nametowidget(parent).winfo_parent()
#self.toplevel = self._nametowidget(gparent)
#self.toplevel = self.app
if hasattr(self.toplevel,'update_callback'):
self.set_update_trace()
else:
log.log(thisfuncname(),3,msg='no update_callback method found on',widget=str(self.toplevel))
#self.sv=StringVar()
self.version = 0
self.current_value = self.init_value = ""
self.widget.s = Style()
self.widget.s.configure(".".join(['InFocus','Notchanged',self.widget.winfo_class()]),
fieldbackground='yellow',
foreground='black')
self.widget.s.configure(".".join(['OutOfFocus','Notchanged',self.widget.winfo_class()]),
fieldbackground='white',
foreground='black')
self.widget.s.configure(".".join(['InFocus','Changed',self.widget.winfo_class()]),
fieldbackground='yellow',
foreground='red')
self.widget.s.configure(".".join(['OutOfFocus','Changed',self.widget.winfo_class()]),
fieldbackground='white',
foreground='red')
self.widget.s.configure(".".join(['InFocus','Label',self.widget.winfo_class()]),
fieldbackground='grey',
foreground='black')
self.widget.s.configure(".".join(['OutOfFocus','Label',self.widget.winfo_class()]),
fieldbackground='grey',
foreground='black')
#self.init_value= self.current_value = ""
self.widget.bind("<Down>",self.refocus)
self.widget.bind("<Left>",self.refocus)
self.widget.bind("<Right>",self.refocus)
self.widget.bind("<Up>",self.refocus)
# for some reason TEntry does not treat Style same as combo so can make these calls in TkBase
if self.winfo_class() == 'TEntry':
self.widget['style']=".".join(['OutOfFocus','Notchanged',self.widget.winfo_class()])
self.widget.bind('<FocusIn>',self.highlight)
self.widget.bind('<FocusOut>',self.highlight)
def session_code_gen(dbname,dryrun=False):
database = Database(dbname)
exec_str = "select s.name,lt.code || '.' || s.code"
exec_str += " from subject as s,lessontype as lt"
exec_str += " where s.lessontype = lt.name"
with database:
colnames,rows = tbl_query(database,exec_str)
subject_lookup = dict((row[0],row[1]) for row in rows)
exec_str = "select teacher,subject,__id,code,type,day from session"
with database:
colnames,rows = tbl_query(database,exec_str)
enums = setenums('All','-1',database)
for row in rows:
teacher = row[0]
subject = row[1]
__id = row[2]
oldcode = row[3]
lessontype = row[4]
dow = row[5]
if dow == None:
dow = "??"
if teacher == None:
teacher_code = "??"
lessontype_code = "??"
if lessontype == "WP":
lessontype_code = "WP"
if subject == None:
subject_code = lessontype_code + ".??"
elif subject_lookup.has_key(subject) == False:
subject_code = lessontype_code + ".??"
else:
subject_code =subject_lookup[subject]
teacher_code = enums['adult']['name2code'][teacher]
#session_code = ".".join([teacher_code,subject_code,])
dow_code = enums['dow']['name2code'][dow]
session_code = ".".join([teacher_code,subject_code,dow_code])
if oldcode <> session_code:
with database:
exec_str,_ = tbl_rows_update(database,'session',
['code',"\""+session_code+"\"",'__id',"\""+__id+"\""],
dryrun=dryrun)
print exec_str,oldcode
log.log(thisfuncname(),4,msg="session code updated",execstr=exec_str,oldcode=oldcode)
def update_callback(ui,widget,new_value):
''' via BaseTk class; all entry widgets assign a callback to the change event
to call this function if it exists '''
#put event on here too
if str(widget.current_value) <> str(new_value):
widget.version += 1
log.log(thisfuncname(),10,msg="updating "+str(widget.winfo_name()),current_value=str(widget.current_value),new_value=new_value,version=str(widget.version))
widget.config(foreground='red')
# record event in update log
ui.updates[str(widget.winfo_name())] = (new_value,widget.version)
else:
widget.config(foreground='black')
log.log(thisfuncname(),9,msg="skipping "+str(widget.winfo_name()),current_value=str(widget.current_value),new_value=new_value,version=str(widget.version))
def lookupenum(enums, converttype, fieldtype, code):
try:
name = enums[fieldtype][converttype][code]
except KeyError, e:
msg = "lookup failed: type={0},field ={1},code={2} [{3}]".format(
converttype, fieldtype, code, e.message, enums[fieldtype])
log.log(thisfuncname(), 2, msg=msg)
raise Exception(msg)
def onchange(self):
if hasattr(self,'pick_widget') == False:
log.log(thisfuncname(),3,msg="no pick label/button defined to display selection")
else:
try:
self.msg_label_sv.set("")
except:
pass
try:
hexcode = self.gethexcode(self.red_entry_sv.get(), self.green_entry_sv.get(), self.blue_entry_sv.get())
config = {self.config:hexcode}
self.pick_widget.config(**config)
log.log(thisfuncname(),3,msg="updating config",config=config)
return 0
except Exception,e:
self.error_sv.set(e)
def highlight(self,event):
log.log(thisfuncname(),9,style=self['style'],inputmode=self.app.current_inputmode,tag="clipboard")
_,state,_ = self['style'].split(".")
# cannot set this earlier as cell widget could be created before its put into the widgets array
# used by highlighter so you can see the col/row hdr associated with cell in focus
_,x,y = self.winfo_name().split(",")
if hasattr(self,'xhdrwidget') == False:
self.xhdrwidget = self.app.widgets[0][int(y)]
self.yhdrwidget = self.app.widgets[int(x)][0]
if event.type == '9':
#if self.toplevel.current_inputmode == "Select":
if self.app.current_inputmode == "Select":
self['style']=".".join(['Select',state,self.winfo_class()])
self.copy_state=True
log.log(thisfuncname(),9,msg="combo in select mode",style=self['style'],tag="clipboard")
else:
self['style']=".".join(['InFocus',state,self.winfo_class()])
self.xhdrwidget['style']=".".join(['InFocus',state,self.winfo_class()])
self.yhdrwidget['style']=".".join(['InFocus',state,self.winfo_class()])
self.copy_state=False
elif event.type == '10':
#if self.toplevel.inputmode_label_sv.get() <> "Select":
if self.app.current_inputmode <> "Select":
self['style']=".".join(['OutOfFocus',state,self.winfo_class()])
self.xhdrwidget['style']=".".join(['OutOfFocus',state,self.winfo_class()])
self.yhdrwidget['style']=".".join(['OutOfFocus',state,self.winfo_class()])
self.copy_state=False
#elif self.toplevel.inputmode_label_sv.get() == "Select":
elif self.app.current_inputmode == "Select":
self['style']=".".join(['Select',state,self.winfo_class()])
self.copy_state=True
self.selectall()
def dataset_loadref(database,
refdatabase,
of,
objtype,
saveversion=1,
unknown='N',
keepversion=False,
whereclause=[]):
# load from database
cols = ['name', 'code', 'enum']
if objtype == "student":
cols.append("prep")
with database:
colndefn, rows, exec_str = tbl_rows_get(database, objtype, cols,
whereclause)
log.log(thisfuncname(), 9, msg="dbread", exec_str=exec_str)
# parse rows
for row in rows:
datamembers = {}
for i in range(len(cols)):
datamembers[cols[i]] = row[i]
datamembers['objtype'] = objtype
datamembers['userobjid'] = datamembers['name']
obj = of.new(schoolschedgeneric,
objtype,
objid=datamembers['name'],
constructor='datamembers',
database=database,
of=of,
modname=__name__,
recursion=False,
dm=datamembers)
log.log(thisfuncname(),
10,
msg="loading row",
objtype=objtype,
dm=datamembers)
def test_1000msg(self):
for i in range(1000):
self.log.log(thisfuncname(),7,)
self.assertEqual(len(self.log.cache),1000)
self.log.logfile.close()
self.assertEqual(self.log.log_file_length(),999)
self.log.log_clean()
def dbbulkloader(database,dbrecords,tblname,cols,maxsize=300):
with database:
dbcoldefn = _gencoldefn(dbrecords[0],cols)
if not tbl_exists(database,tblname) ==True:
tbl_create(database,tblname,dbcoldefn)
dbrecords = _quotestrs(dbrecords)
if len(dbrecords) > maxsize:
for starti in range(0,len(dbrecords),maxsize):
if starti+maxsize > len(dbrecords):
endi = len(dbrecords)
else:
endi = starti + maxsize
tbl_rows_insert(database,tblname,cols,dbrecords[starti:endi])
log.log(thisfuncname(),10,msg="loaded rows to "+tblname,numrow=endi-starti)
else:
tbl_rows_insert(database,tblname,cols,dbrecords)
log.log(thisfuncname(),10,msg="loaded rows to "+tblname,numrow=len(dbrecords))
def persist(self):
with self.database:
for obj in self.of.object_iter():
exec_str, result = obj.persist()
log.log(thisfuncname(),
9,
msg="persisting of obj",
objid=str(obj),
exec_str=exec_str,
result=result)
def persist_lesson(self):
with self.database:
for objid in self.of.store['lesson']:
exec_str, result = self.of.store['lesson'][objid].persist()
log.log(thisfuncname(),
9,
msg="persisting of obj",
objid=objid,
exec_str=exec_str,
result=result)
def selection_clear(self):
for x in range(1,self.maxrows):
for y in range(1,self.maxcols):
if self.widgets[x][y].copy_state == True:
self.widgets[x][y].unhighlight()
self.widgets[x][y].copy_state == False
log.log(thisfuncname(),9,msg="input mode set",currentmode= self.current_inputmode,
newmode="Normal",tag="clipboard")
self.current_inputmode = "Normal"
self.inputmode_label_sv.set(self.current_inputmode)
def updates_get(ui, gridname, ignoreaxes=False):
maxx = maxy = -1
if ignoreaxes == True: maxx = maxy = 0
update_keys = [[gridname,
update.split(",")[1],
update.split(",")[2]] for update in ui.updates.keys()
if update.split(",")[0] == gridname
if int(update.split(",")[1]) > maxx
if int(update.split(",")[2]) > maxy]
if len(update_keys) == 0:
log.log(thisfuncname(),
3,
msg="updates requested but none found",
gridname=gridname)
#raise Exception("no updates registered for",gridname)
else:
if ignoreaxes == False:
offset = 1
else:
offset = 0
xsize = max([int(key[1]) for key in update_keys]) + offset
ysize = max([int(key[2]) for key in update_keys]) + offset
# text values of widgets
values = nxnarraycreate(int(xsize), int(ysize), "")
for key in update_keys:
if ignoreaxes == False:
offset = 0
else:
offset = -1
values[int(key[1]) + offset][int(key[2]) +
offset] = ui.updates[str(
",".join(key))]
# background color of widgets
bgcolor = nxnarraycreate(int(xsize), int(ysize), "")
for key in update_keys:
grid = getattr(ui, gridname)
#_color = self.balancegrid.widgets[int(key[1])][int(key[2])].cget('background')
_color = grid.widgets[int(key[1])][int(key[2])].cget('background')
bgcolor[int(key[1]) - 1][int(key[2]) - 1] = _color
return values, bgcolor
return 0, 0
def clipboard_add_selection(self,cut=False):
_clipboard = []
if self.current_inputmode == "Normal": # single cell copy
_,tx,ty = self.focus_get().winfo_name().split(",")
widget = self.widgets[int(tx)][int(ty)]
_clipboard.append((int(tx),int(ty)))
widget.copy_state=False
widget.unhighlight()
else:
for x in range(1,self.maxrows):
for y in range(1,self.maxcols):
if self.widgets[x][y].copy_state == True:
widget = self.widgets[x][y]
_,tx,ty = widget.winfo_name().split(",")
_clipboard.append((int(tx),int(ty)))
widget.copy_state=False
widget.unhighlight()
if cut==True: # delete source cell content
self.widgets[x][y].set("")
self.current_inputmode = "Normal"
#self.inputmode_label_sv.set(self.current_inputmode)
log.log(thisfuncname(),9,msg="added to clipboard",clipboard= _clipboard,tag="clipboard")
self.clipboard.append(_clipboard)
#self.clipboard_size_label_sv.set(len(self.clipboard))
# set the current clipboard selection to the latest
self.clipboard_selection = len(self.clipboard)
#self.clipboard_selected_label_sv.set(self.clipboard_selection)
log.log(thisfuncname(),9,msg="input mode set",currentmode= self.current_inputmode,tag="clipboard")
def dbinsert(database,dbclassname,rows,colnames):
dbclass = dbtblfactory(dbclassname)
for x in range(len(rows)):
dm={}
emptyrow=True
for y in range(len(colnames)):
colname = colnames[y]
value = rows[x][y]
if colname <> "" and colname.startswith("_") == False:
if value <> "":
dm[colname] = value
emptyrow=False
if emptyrow == False:
dbobj = dbclass.datamembers(database=database,dm=dm)
with database:
try:
exec_str,result = dbobj.persist()
log.log(thisfuncname(),4,func=dbobj.persist,exec_str=exec_str,result=result)
except Exception, e:
log.log(thisfuncname(),1,func=dbobj.persist,error=str(e))
def __init__(self,master,var,**kwargs):
if not isadatatype(var):
raise Exception('arg datatype must be a valid type')
self.sv=StringVar()
Entry.__init__(self,master,
textvariable=self.sv,
**kwargs)
TKBase.__init__(self,self,**kwargs)
self.sv.trace("w",lambda name,index,mode,sv=self.sv:
self.changed(self.sv))
log.log(thisfuncname(),10,func=self.__init__)
def onchange(self):
try:
self.msg_label_sv.set("")
except:
pass
try:
font = tkFont.Font(family=self.family_entry_sv.get(),
size=self.pointsize_entry_sv.get(),
weight=self.weight_entry_sv.get())
self.pick_widget.config(font=font)
log.log(thisfuncname(),3,msg="updating font",font=font)
return 0
except Exception,e:
self.error_sv.set(e)
def __init__(self,master,var,**kwargs):
if not isadatatype(var):
raise Exception('arg datatype must be a valid type')
self.sv=StringVar()
Entry.__init__(self,master,
textvariable=self.sv,
**kwargs)
TKBase.__init__(self,self,**kwargs)
#self.widget.config(relief=FLAT,borderwidth=1,highlightthickness=0)
self.style_on = ".".join(['On','Notchanged',self.widget.winfo_class()])
self.widget.s.configure(self.style_on,fieldbackground='green',foreground='black',
relief=FLAT,borderwidth=1,highlightthickness=0)
log.log(thisfuncname(),10,func=self.__init__)
def dataset_list(of,
enums=None,
objtype='lesson',
pagelen=30,
pagenum=1,
constraints=[],
columns=None):
try:
source_objs = of.query_advanced(objtype, constraints)
except KeyError:
log.log(thisfuncname(),
3,
msg="list requested and no members found",
objtype=objtype,
constraints=constraints)
return [], []
grid = []
colnames = list(source_objs[0].dm.keys())
# first row is the column headers; if specific columns are provided
# then remove from colnames before adding
if columns <> None and columns <> []:
colnames = columns
grid.append(colnames)
startrow, endrow = _getpage(source_objs, pagelen, pagenum)
for i in range(startrow, endrow + 1):
if columns == None or columns == []:
columns = colnames
#grid.append(source_objs[i].dm.values())
#else:
_l = []
for col in columns:
try:
_l.append(source_objs[i].dm[col])
except:
_l.append("none")
grid.append(_l)
return grid, colnames
def clipboard_paste(self):
_clipboard = self.clipboard[self.clipboard_selection-1]
_,tx,ty = self.focus_get().winfo_name().split(",")
tx = int(tx)
ty = int(ty)
# workout offset from the first cell saved in the selection
ox,oy = _clipboard[0]
dx = tx-ox
dy = ty-oy
log.log(thisfuncname(),9,msg="paste clipboard",clipboard= _clipboard,tag="clipboard")
for x,y in _clipboard:
newx = x+dx
newy = y+dy
self.widgets[newx][newy].sv.set(self.widgets[x][y].sv.get())
def updates_get(ui,gridname,ignoreaxes=False):
maxx = maxy = -1
if ignoreaxes == True: maxx = maxy = 0
update_keys = [ [gridname,update.split(",")[1],update.split(",")[2]] for update in ui.updates.keys() if update.split(",")[0] == gridname if int(update.split(",")[1]) > maxx if int(update.split(",")[2]) > maxy]
if len(update_keys)==0:
log.log(thisfuncname(),3,msg="updates requested but none found",gridname=gridname)
#raise Exception("no updates registered for",gridname)
else:
if ignoreaxes == False:
offset = 1
else:
offset = 0
xsize= max([int(key[1]) for key in update_keys]) + offset
ysize= max([int(key[2]) for key in update_keys]) + offset
# text values of widgets
values = nxnarraycreate(int(xsize),int(ysize),"")
for key in update_keys:
if ignoreaxes == False:
offset = 0
else:
offset = -1
values[int(key[1])+offset][int(key[2])+offset] = ui.updates[str(",".join(key))]
# background color of widgets
bgcolor = nxnarraycreate(int(xsize),int(ysize),"")
for key in update_keys:
grid = getattr(ui,gridname)
#_color = self.balancegrid.widgets[int(key[1])][int(key[2])].cget('background')
_color = grid.widgets[int(key[1])][int(key[2])].cget('background')
bgcolor[int(key[1])-1][int(key[2])-1] = _color
return values,bgcolor
return 0,0
def __init__(self,
dbname,
of,
refdbname,
maxentrycols=3,
maxentryrows=4,
maxnewrowcols=3,
maxnewrowrows=3):
log.log(thisfuncname(),
3,
msg="initialize",
dbname=dbname,
refdbname=refdbname)
self.clipboard = []
self.clipboard_selection = -1
Tk.__init__(self)
self.geometry("2000x500+0+0")
self.refdatabase = Database(refdbname)
#self.enums = sswizard_utils.setenums('All','5',self.refdatabase)
self.dbname = dbname
self.database = Database(self.dbname)
self.of = of
font = tkFont.Font(family="monospace", size=12)
self.lastsaveversion = 0
style = Style()
style.theme_use("default")
bigfont = tkFont.Font(family="Helvetica", size=50)
self.option_add("*TCombobox*Listbox*Font", bigfont)
self.current_inputmode = "Normal"
set_configs(style)
# any children that change update this
# key is the name and value is the new val
# the name is likely to be the tkwidgetid.x,y
self.updates = OrderedDict()
self.maxrows = maxentryrows # rows in the grid
self.maxcols = maxentrycols # cols in the grid
maxwidgets = self.maxrows * self.maxcols
wwidth = 48 # default button width with text of 3 chars
wheight = 29 # default button height
wmheight = wheight * self.maxrows # master height
wmwidth = wwidth * self.maxcols # master width
#geom = geometry_get(1000,1000,0,0)
#self.geometry(geom)
self.bind("<Prior>", self.focus_next_widget)
# daygrids
setmemberp = SetMemberPartial(name='x{mylist}', set=['Monday'])
widget_args = dict(background='white',
width=9,
font=font,
values=['Monday'])
widgetcfg = nxnarraycreate(self.maxrows, self.maxcols, widget_args)
# daygrid 1
self.dowentrygrid = TkImageLabelGrid(self, 'dowentrygrid', setmemberp,
wmwidth, wmheight, 0, 0, 1,
self.maxcols, True, {}, widgetcfg)
self.dowentrygrid.grid(row=0, column=0, sticky=EW)
# entrygrids
setmemberp = SetMemberPartial(name='x{mylist}', set=[])
widget_args = dict(background='white', width=9, font=font, values=[])
widgetcfg = nxnarraycreate(self.maxrows, self.maxcols, widget_args)
# entrygrid 1
setmemberp.widgettype = TkGridCombobox
self.entrygrid = TkImageLabelGrid(self, 'entrygrid', setmemberp,
wmwidth, wmheight, 0, 0,
self.maxrows, self.maxcols, True,
True, {}, widgetcfg)
self.entrygrid['style'] = 'EntryGrid.TFrame'
self.entrygrid.grid(row=1, column=0, sticky=NSEW)
buttonpanel = Frame(self, style='ControlPanel.TFrame')
buttonpanel.grid(row=2, column=0, sticky=NSEW, columnspan=2)
self.save_button = Button(buttonpanel,
command=self.save,
text="save",
name="svb")
self.save_button.grid(row=0, column=0)
self.save_button.focus_get()
self.persist_button = Button(buttonpanel,
command=self.persist_lesson,
text="persist",
name="pb")
self.persist_button.grid(row=0, column=1)
self.persist_button.focus_get()
self.dbload_button = Button(buttonpanel,
command=self.load,
text="dbload",
name="dbl")
self.dbload_button.grid(row=0, column=2)
self.dbload_button.focus_get()
self.clear_button = Button(buttonpanel,
command=self.clear,
text="clear",
name="clr")
self.clear_button.grid(row=0, column=3)
self.clear_button.focus_get()
self.viewer_button = Button(buttonpanel,
command=self.viewer,
text="viewer",
name="view")
self.viewer_button.grid(row=0, column=4)
self.viewer_button.focus_get()
self.rebuilddropdown_button = Button(buttonpanel,
command=self.dropdowns_set,
text="ddown",
name="ddown")
self.rebuilddropdown_button.grid(row=0, column=5)
self.rebuilddropdown_button.focus_get()
controlpanel = Frame(self, style='ControlPanel.TFrame')
controlpanel.grid(row=3, column=0, sticky=NSEW, columnspan=2)
self.dbload_entry_label = Label(controlpanel, text="version")
self.dbload_entry_label.grid(row=0, column=0)
self.dbload_entry_label.focus_get()
self.dbload_entry_sv = StringVar()
self.dbload_entry = Entry(controlpanel,
textvariable=self.dbload_entry_sv)
self.dbload_entry.grid(row=0, column=1)
self.dbload_entry.focus_get()
self.dbname_entry_label = Label(controlpanel, text="dbname")
self.dbname_entry_label.grid(row=0, column=2)
self.dbname_entry_label.focus_get()
self.dbname_entry_sv = StringVar()
self.dbname_entry = Entry(controlpanel,
textvariable=self.dbname_entry_sv)
self.dbname_entry.grid(row=0, column=3)
self.dbname_entry.focus_get()
self.dbname_entry_sv.set(self.dbname)
self.dow_entry_label = Label(controlpanel, text="dow", width=10)
self.dow_entry_label.grid(row=0, column=4)
self.dow_entry_label.focus_get()
self.dow_entry_sv = StringVar()
self.dow_entry = Entry(controlpanel,
textvariable=self.dow_entry_sv,
width=10)
self.dow_entry.grid(row=0, column=5)
self.dow_entry.focus_get()
self.dow_entry_sv.set('MO')
self.prep_label = Label(controlpanel, text="prep", width=10)
self.prep_label.grid(row=0, column=6)
self.prep_label.focus_get()
self.prep_entry_sv = StringVar()
self.prep_entry = Entry(controlpanel,
textvariable=self.prep_entry_sv,
width=10)
self.prep_entry.grid(row=0, column=7)
self.prep_entry.focus_get()
self.prep_entry_sv.set(5)
self.grid_rowconfigure(0, weight=1, uniform="foo")
self.grid_rowconfigure(1, weight=10, uniform="foo")
self.grid_rowconfigure(2, weight=1, uniform="foo")
self.grid_rowconfigure(3, weight=1, uniform="foo")
self.grid_columnconfigure(0, weight=1, uniform="foo")
def load(self, saveversion=None, values=None, dow=None, prep=None):
whereclause = []
# dbname
if self.dbname <> self.dbname_entry_sv.get():
log.log(thisfuncname(),
3,
msg="dbname changed",
oldname=self.dbname,
newname=self.dbname_entry_sv.get())
self.database = Database(self.dbname_entry_sv.get())
self.dbname = self.dbname_entry_sv.get()
# make sure that the refdatabase is the same as the database
self.refdatabase = Database(self.dbname_entry_sv.get())
# saveversion
if saveversion == None or saveversion == "":
saveversion = self.dbload_entry_sv.get()
if saveversion == "":
log.log(thisfuncname(),
1,
msg="no saveversion set for load; exception")
raise Exception("attempting to load without a saveversion set")
else:
log.log(thisfuncname(),
3,
msg="loading",
saveversion=str(saveversion))
whereclause.append(['saveversion', "=", saveversion])
# prep
if prep == None: prep = self.prep_entry_sv.get()
if prep == "":
prep = -1
else:
whereclause.append(['prep', "=", prep])
log.log(thisfuncname(), 3, msg="loading", prep=str(prep))
# dow
if dow == None: dow = self.dow_entry_sv.get()
if dow == "":
dow = "all"
else:
whereclause.append(['dow', "=", "\"" + dow + "\""])
log.log(thisfuncname(), 3, msg="loading", dow=str(dow))
# get enums
self.enums = sswizard_utils.setenums(dow, prep, self.refdatabase)
whereclause.append(['saveversion', "=", saveversion])
log.log(thisfuncname(), 3, msg="loading", saveversion=str(saveversion))
cols = ['period', 'student', 'session', 'dow']
if values == None:
with self.database:
whereclause.append(['teacher', "<>", "\"" + "??" + "\""])
colndefn, rows, exec_str = tbl_rows_get(
self.database, 'lesson', cols, whereclause)
log.log(thisfuncname(), 9, msg="dbread", exec_str=exec_str)
whereclause = whereclause[:-1]
whereclause.append(['teacher', "=", "\"" + "??" + "\""])
colndefn, noteacherrows, exec_str = tbl_rows_get(
self.database, 'lesson', cols, whereclause)
log.log(thisfuncname(), 9, msg="dbread", exec_str=exec_str)
if len(rows) == 0:
log.log(thisfuncname(),
2,
msg="no rows detected",
whereclause=whereclause)
for row in rows:
z = session = row[cols.index('session')]
period = row[cols.index('period')]
student = row[cols.index('student')]
x = self.enums['student']['name2enum'][student]
y = self.enums['period']['name2enum'][str(period)]
self.entrygrid.widgets[x][y].sv.set(session)
self.entrygrid.widgets[0][y].sv.set(period)
self.entrygrid.widgets[x][0].sv.set(student)
log.log(thisfuncname(),
3,
msg="loading row",
period=period,
student=str(student),
sv=saveversion,
x=x,
y=y,
value=z)
for noteacherrow in noteacherrows:
z = session = noteacherrow[cols.index('session')]
period = noteacherrow[cols.index('period')]
student = noteacherrow[cols.index('student')]
x = self.enums['student']['name2enum'][student]
y = self.enums['period']['name2enum'][str(period)]
if self.entrygrid.widgets[x][y].sv.get() == "":
self.entrygrid.widgets[x][y].sv.set(session)
log.log(thisfuncname(),
3,
msg="loading no teacher row",
period=period,
student=str(student),
sv=saveversion,
x=x,
y=y,
value=z)
else:
for x in range(len(values)):
for y in range(len(values[0])):
self.entrygrid.widgets[x][y].sv.set(values[x][y])
def dataset_add(database,
refdatabase,
of,
enums,
prepmap,
datamembers,
objtype='lesson',
keepversion=False):
'''
in the datamembers dict needs to come 'period','student','dow','adult','subject','recordtype
values need to be the names for dow, so 'Monday','Tuesday' etc'''
_objid = None
_userobjid = None
if objtype == "lesson":
if (datamembers.has_key('adult') == False
and datamembers.has_key('teacher') == True):
datamembers['adult'] = datamembers['teacher']
datamembers.pop('teacher')
datamembers['session'] = ".".join([
datamembers['adult'], datamembers['subject'], datamembers['dow'],
sswizard_utils._isname(enums, 'period', datamembers['period'])
])
datamembers['userobjid'] = sswizard_utils._getuserobjid(
enums, ['period', 'dow', 'student', 'adult', 'subject'],
datamembers)
# check that the userobjid does not already exist
if of.object_exists('lesson', datamembers['userobjid']) == True:
raise OFDuplicateRecord("id already in use",
datamembers['userobjid'])
datamembers['objtype'] = 'lesson'
datamembers['substatus'] = 'complete'
datamembers['status'] = 'master'
datamembers['prep'] = int(prepmap[datamembers['student']])
datamembers['source'] = "manual"
#datamembers['saveversion']=1
# switch to code
datamembers['dow'] = sswizard_utils._iscode(enums, 'dow',
datamembers['dow'])
lesson = of.new(schoolschedgeneric,
'lesson',
objid=datamembers['userobjid'],
constructor='datamembers',
database=database,
of=of,
modname=__name__,
dm=datamembers)
_lesson_change(lesson)
log.log(thisfuncname(),
10,
msg="lesson obj added",
objtype=objtype,
dm=datamembers)
with database:
lesson.keepversion = keepversion
lesson.persist()
return (lesson)
else:
if objtype == "student":
prepmap[datamembers['name']] = datamembers['prep']
with database:
_, _obj_count, _ = sswizard_query_utils._rowcount(
database, objtype)
_enum = int(_obj_count[0][0]) + 1
sswizard_utils._addenum(enums, objtype, datamembers['name'],
datamembers['code'], _enum)
if _userobjid == None:
_userobjid = datamembers[
'name'] # set the of unique id (use name for all non lesson objects
if _objid == None:
_objid = datamembers['name']
datamembers['userobjid'] = _userobjid
datamembers['enum'] = _enum
datamembers['objtype'] = objtype
obj = of.new(schoolschedgeneric,
str(objtype),
objid=_objid,
constructor='datamembers',
database=database,
of=of,
modname=__name__,
recursion=False,
dm=datamembers)
log.log(thisfuncname(),
10,
msg="lesson obj added",
objtype=objtype,
dm=datamembers)
with database:
obj.persist()
return (obj)
def save(self, saveversion=None):
self.of.reset()
if self.dbname <> self.dbname_entry_sv.get():
log.log(thisfuncname(),
3,
msg="dbname changed",
oldname=self.dbname,
newname=self.dbname_entry_sv.get())
self.database = Database(self.dbname_entry_sv.get())
self.dbname = self.dbname_entry_sv.get()
# make sure that the refdatabase is the same as the database
self.refdatabase = Database(self.dbname_entry_sv.get())
if saveversion == None or saveversion == "":
if self.dbload_entry_sv.get() == None or self.dbload_entry_sv.get(
) == "":
log.log(thisfuncname(),
1,
msg="no saveversion set for save; exception")
raise Exception("attempting to save without a saveversion set")
else:
saveversion = self.dbload_entry_sv.get()
# prep
prep = self.prep_entry_sv.get()
if prep == "": prep = -1
# dow
dow = self.dow_entry_sv.get()
if dow == "": dow = "all"
log.log(thisfuncname(),
3,
msg="saving save version=",
saveversion=str(saveversion),
prep=prep,
dow=dow)
# get enums
self.enums = sswizard_utils.setenums(dow, prep, self.refdatabase)
for x in range(1, self.maxrows):
for y in range(1, self.maxcols):
period = self.entrygrid.widgets[0][y].sv.get()
student = self.entrygrid.widgets[x][0].sv.get()
session = self.entrygrid.widgets[x][y].sv.get()
if session <> "":
period_enum = x
student_enum = y
session_enum = self.enums['session']['name2enum'][session]
obj_id = ",".join(
map(str, [period_enum, student_enum, session_enum]))
#obj_id = session
teacher_code, lessontype_code, subject_code, dow = session.split(
".")
try:
teacher = self.enums['adult']['code2name'][
teacher_code]
except KeyError:
log.log(thisfuncname(),
5,
msg="could not find in enum; using **",
teacher_code=teacher_code)
teacher = "**"
try:
lessontype = self.enums['lessontype']['code2name'][
lessontype_code]
except KeyError:
log.log(thisfuncname(),
5,
msg="could not find in enum; using **",
lessontype_code=lessontype_code)
lessontype = "**"
try:
subject = self.enums['subject']['code2name'][
subject_code]
except KeyError:
log.log(thisfuncname(),
5,
msg="could not find in enum; using **",
subject_code=subject_code)
subject = "**"
datamembers = dict(
schedule='1',
dow=dow,
subject=subject,
lessontype=lessontype,
objtype='lesson',
userobjid=obj_id, # unique key to store obj in of
period=period,
prep=prep,
student=student,
teacher=teacher,
saveversion=saveversion,
session=session)
lesson = self.of.new(schoolschedgeneric,
'lesson',
objid=obj_id,
constructor='datamembers',
database=self.database,
of=self.of,
modname=__name__,
dm=datamembers)
setattr(self.entrygrid.widgets[x][y], "lesson", lesson)
self.lesson_change(lesson)
def dataset_load(database,
refdatabase,
of,
enums,
saveversion=1,
unknown='N',
prep=-1,
period="all",
dow="all",
teacher="all",
student="all",
source="dbinsert",
keepversion=False):
of.reset()
whereclause = []
if keepversion == True:
''' if versioning enabled make sure to only recover the latest/current version '''
whereclause = [['__version', '=', "\"current\""]]
# saveversion
log.log(thisfuncname(), 3, msg="loading", saveversion=str(saveversion))
whereclause.append(['saveversion', "=", saveversion])
# unknown
if unknown == 'N':
whereclause.append(['student', "<>", "\"??\""])
whereclause.append(['subject', "<>", "\"??\""])
whereclause.append(['teacher', "<>", "\"??\""])
log.log(thisfuncname(), 3, msg="loading", unknown=str(unknown))
# prep
if prep <> -1:
whereclause.append(['prep', "=", prep])
log.log(thisfuncname(), 3, msg="loading", prep=str(prep))
# period
if period <> "all":
whereclause.append(['period', "=", "\"" + period + "\""])
log.log(thisfuncname(), 3, msg="loading", prep=str(prep))
# dow
if dow <> "all":
whereclause.append(['dow', "=", "\"" + dow + "\""])
log.log(thisfuncname(), 3, msg="loading", dow=str(dow))
# teacher
if teacher <> "all":
whereclause.append(['teacher', "=", "\"" + teacher + "\""])
log.log(thisfuncname(), 3, msg="loading", teacher=str(teacher))
# student
if student <> "all":
whereclause.append(['student', "=", "\"" + student + "\""])
log.log(thisfuncname(), 3, msg="loading", student=str(student))
# source
#if source <> "dbinsert":
_sources = ["\"" + _source + "\"" for _source in source.split(",")]
whereclause.append(['source', "in", "(" + ",".join(_sources) + ")"])
log.log(thisfuncname(), 3, msg="loading", source=str(source))
# load from database
#cols = ['period','student','session','dow','prep','teacher','subject','userobjid','status','substatus','recordtype','source','__id','record']
cols = [
'period', 'student', 'session', 'dow', 'prep', 'teacher', 'subject',
'userobjid', 'status', 'substatus', 'recordtype', 'source', '__id'
]
with database:
colndefn, rows, exec_str = tbl_rows_get(database, 'lesson', cols,
whereclause)
log.log(thisfuncname(), 9, msg="dbread", exec_str=exec_str)
#cols = ['period','student','session','dow','prep','adult','subject','userobjid','status','substatus','recordtype','source','id','record']
cols = [
'period', 'student', 'session', 'dow', 'prep', 'adult', 'subject',
'userobjid', 'status', 'substatus', 'recordtype', 'source', 'id'
]
# parse rows
for row in rows:
datamembers = {}
for i in range(len(cols)):
datamembers[cols[i]] = row[i]
# this is a hack to quickly get a clean lessontype into the server
datamembers['recordtype'] = datamembers['recordtype'].split(".")[0]
if datamembers['recordtype'] == "subject":
datamembers['recordtype'] = "academic"
_, lessontype_code, _, _ = datamembers['session'].split(".")
datamembers['objtype'] = 'lesson'
lesson = of.new(schoolschedgeneric,
'lesson',
objid=datamembers['userobjid'],
constructor='datamembers',
database=database,
of=of,
modname=__name__,
dm=datamembers)
_lesson_change(lesson)
log.log(thisfuncname(), 3, msg="loading row", dm=datamembers)
# post log with results
log.log(thisfuncname(), 3, msg="db rows loaded", num=len(rows))
for i in range(len(cols)):
if of.store.has_key(cols[i]):
log.log(thisfuncname(),
3,
msg="lesson obj created",
num=len(of.store[cols[i]]))
else:
log.log(thisfuncname(),
3,
msg="no records found to be loaded for",
record=cols[i])
def load(self,
saveversion=None,
dow=None,
prep=None,
period=None,
teacher=None,
student=None,
source=None,
unknown=None):
self.of.reset()
# database name
if self.dbname_entry_sv.get() <> self.dbname:
newdb = self.dbname_entry_sv.get()
log.log(thisfuncname(),
3,
msg="switching databases",
olddb=self.dbname,
newdb=newdb)
self.database = Database(newdb)
self.dbname = newdb
# saveversion
if saveversion == None or saveversion == "":
saveversion = self.dbload_entry_sv.get()
if saveversion == "":
log.log(thisfuncname(),
1,
msg="no saveversion set for load; exception")
raise Exception("attempting to load without a saveversion set")
# unknown
if unknown == None:
unknown = self.unknown_checkbutton_sv.get()
# prep
if prep == None: prep = self.prep_entry_sv.get()
if prep == "":
prep = -1
# period
if period == None: period = self.period_entry_sv.get()
if period == "":
period = "all"
# dow
if dow == None: dow = self.dow_entry_sv.get()
if dow == "":
dow = "all"
# teacher
if teacher == None: teacher = self.teacher_label_sv.get()
if teacher == "":
teacher = "all"
# student
if student == None: student = self.student_label_sv.get()
if student == "":
student = "all"
# source
if source == None: source = self.source_label_sv.get()
if source == "":
source = "dbinsert"
# get enums
self.enums = sswizard_utils.setenums(dow, prep, self.refdatabase)
ssviewer_utils.dataset_load(self.database, self.refdatabase, self.of,
self.enums, saveversion, unknown, prep,
period, dow, teacher, student, source)
# get enums
self.enums = sswizard_utils.setenums(dow, prep, self.refdatabase)
class DBTableUI(Tk):
def __init__(self,maxentrycols=18,maxentryrows=12,
maxnewrowcols=16,maxnewrowrows=3):
Tk.__init__(self)
self.lastsaveversion=0
# any children that change update this
# key is the name and value is the new val
# the name is likely to be the tkwidgetid.x,y
self.updates = OrderedDict()
# clipboard stuff
self.clipboard=[]
self.clipboard_selection=-1
# dbm columns are added here as they are loaded
# .index+1 will give the col # on the grid that corresponds
# useful for looking up pk values for updates
self.dbcol_defn = []
self.maxrows=maxentryrows # rows in the grid
self.maxcols=maxentrycols # cols in the grid
#self.maxrows=57 # rows in the grid
#self.maxcols=15 # cols in the grid
maxwidgets=self.maxrows*self.maxcols
wwidth=48 # default button width with text of 3 chars
wheight=29 # default button height
wmheight=wheight*20 # master height
wmwidth=wwidth*20 # master width
geom = geometry_get(1500,2000,0,0)
self.geometry(geom)
#master.bind("<Prior>",self.focus_next_widget)
self.bind("<Prior>",self.focus_next_widget)
self.grid()
font = tkFont.Font(family="monospace", size=10)
# entry grid origin label
xlbl_widget_args=dict(width=10,font=font)
xlbl_widgetcfg = nxnarraycreate(self.maxrows,self.maxcols,xlbl_widget_args)
mytruefalse = TrueFalse(name='truefalse')
self.entrygridolbl = TkImageLabelGrid(self,'entrygridolbl',mytruefalse,2,wmheight,
0,0,1,1,False,{},xlbl_widgetcfg)
self.entrygridolbl.grid(row=0,column=0,rowspan=2,sticky=NS)
# entry grid y label
ylbl_widget_args=dict(width=10,font=font)
ylbl_widgetcfg = nxnarraycreate(self.maxrows,self.maxcols,ylbl_widget_args)
mytextalphanumro = TextAlphaNum(name='textalphanum')
self.entrygridylabel = TkImageLabelGrid(self,'entrygridylbl',mytextalphanumro,2,wmheight,
0,0,1,self.maxcols,False,False,{},ylbl_widgetcfg)
self.entrygridylabel.grid(row=0,column=1,sticky=EW)
for i in range(self.maxcols):
self.entrygridylabel.widgets[0][i].sv.set(i+1)
self.entrygridylabel.widgets[0][i]['style'] = 'InFocus.Label.TEntry'
# entry grid x label
xlbl_widget_args=dict(width=10,font=font)
xlbl_widgetcfg = nxnarraycreate(self.maxrows,self.maxcols,xlbl_widget_args)
mytextalphanum = TextAlphaNum(name='textalphanum')
mytextalphanum.widgettype = TkGridEntry
#mytruefalse = TrueFalse(name='truefalse')
#self.entrygridxlabel = TkImageLabelGrid(self,'entrygridxlbl',mytruefalse,2,wmheight,
# 0,0,self.maxrows,1,False,False,{},xlbl_widgetcfg)
self.entrygridxlabel = TkImageLabelGrid(self,'entrygridxlbl',mytextalphanum,2,wmheight,
0,0,self.maxrows,1,False,False,{},xlbl_widgetcfg)
self.entrygridxlabel.grid(row=1,column=0,rowspan=1,sticky=NS)
for i in range(self.maxrows):
self.entrygridxlabel.widgets[i][0].sv.set(i+1)
self.entrygridxlabel.widgets[i][0]['style'] = 'InFocus.Label.TEntry'
# entry grid
widget_args=dict(background='white',width=20,font=font)
widgetcfg = nxnarraycreate(self.maxrows,self.maxcols,widget_args)
mytextalphanum = TextAlphaNum(name='textalphanum')
mytextalphanum.widgettype = TkGridEntry
self.entrygrid = TkImageLabelGrid(self,'entrygrid',mytextalphanum,wmwidth,wmheight,
0,0,self.maxrows,self.maxcols,
False,True,{},widgetcfg)
self.entrygrid.grid(row=1,column=1,sticky=NSEW)
# dbcontrolpanel
dbcontrolpanel = Frame(self)
dbcontrolpanel.grid(row=2,column=1,sticky=NSEW,padx=10,pady=10)
self.dbname_label = Label(dbcontrolpanel,text="database",width=10)
self.dbname_label.grid(column=0,row=1,sticky=NSEW)
self.dbname_label.focus_get()
self.dbname_entry_sv = StringVar()
self.dbname_entry = Entry(dbcontrolpanel,textvariable=self.dbname_entry_sv)
self.dbname_entry.grid(column=1,row=1,sticky=NSEW)
self.dbname_entry.focus_get()
self.dbname_entry_sv.set("htmlparser")
self.tblname_label = Label(dbcontrolpanel,text="table",width=10)
self.tblname_label.grid(column=0,row=2,sticky=NSEW)
self.tblname_label.focus_get()
self.tblname_entry_sv = StringVar()
self.tblname_entry = Entry(dbcontrolpanel,textvariable=self.tblname_entry_sv)
self.tblname_entry.grid(column=1,row=2,sticky=NSEW)
self.tblname_entry.focus_get()
self.tblname_entry_sv.set("lesson")
# query predicate 1
self.pred1_label = Label(dbcontrolpanel,text="pred1",width=10)
self.pred1_label.grid(column=7,row=1,sticky=NSEW)
self.pred1_label.focus_get()
self.pred1_entry_sv = StringVar()
self.pred1_entry = Entry(dbcontrolpanel,textvariable=self.pred1_entry_sv)
self.pred1_entry.grid(column=8,row=1,sticky=NSEW)
self.pred1_entry.focus_get()
# query predicate value 1
self.pred1_op_entry_sv = StringVar()
self.pred1_op_entry = Entry(dbcontrolpanel,textvariable=self.pred1_op_entry_sv)
self.pred1_op_entry.grid(column=9,row=1,sticky=NSEW)
self.pred1_op_entry.focus_get()
self.pred1_op_entry_sv.set("=")
self.predval1_entry_sv = StringVar()
self.predval1_entry = Entry(dbcontrolpanel,textvariable=self.predval1_entry_sv)
self.predval1_entry.grid(column=10,row=1,sticky=NSEW)
self.predval1_entry.focus_get()
# query predicate 2
self.pred2_label = Label(dbcontrolpanel,text="pred2",width=10)
self.pred2_label.grid(column=7,row=2,sticky=NSEW)
self.pred2_label.focus_get()
self.pred2_entry_sv = StringVar()
self.pred2_entry = Entry(dbcontrolpanel,textvariable=self.pred2_entry_sv)
self.pred2_entry.grid(column=8,row=2,sticky=NSEW)
self.pred2_entry.focus_get()
# query predicate value 2
self.pred2_op_entry_sv = StringVar()
self.pred2_op_entry = Entry(dbcontrolpanel,textvariable=self.pred2_op_entry_sv)
self.pred2_op_entry.grid(column=9,row=2,sticky=NSEW)
self.pred2_op_entry.focus_get()
self.pred2_op_entry_sv.set("=")
self.predval2_entry_sv = StringVar()
self.predval2_entry = Entry(dbcontrolpanel,textvariable=self.predval2_entry_sv)
self.predval2_entry.grid(column=10,row=2,sticky=NSEW)
self.predval2_entry.focus_get()
# query predicate 3
self.pred3_label = Label(dbcontrolpanel,text="pred3",width=10)
self.pred3_label.grid(column=7,row=3,sticky=NSEW)
self.pred3_label.focus_get()
self.pred3_entry_sv = StringVar()
self.pred3_entry = Entry(dbcontrolpanel,textvariable=self.pred3_entry_sv)
self.pred3_entry.grid(column=8,row=3,sticky=NSEW)
self.pred3_entry.focus_get()
# query predicate value 3
self.pred3_op_entry_sv = StringVar()
self.pred3_op_entry = Entry(dbcontrolpanel,textvariable=self.pred3_op_entry_sv)
self.pred3_op_entry.grid(column=9,row=3,sticky=NSEW)
self.pred3_op_entry.focus_get()
self.pred3_op_entry_sv.set("=")
self.predval3_entry_sv = StringVar()
self.predval3_entry = Entry(dbcontrolpanel,textvariable=self.predval3_entry_sv)
self.predval3_entry.grid(column=10,row=3,sticky=NSEW)
self.predval3_entry.focus_get()
# primary key specifier
self.pkentry_label = Label(dbcontrolpanel,text="pk",width=10)
self.pkentry_label.grid(column=11,row=1,sticky=NSEW)
self.pkentry_label.focus_get()
self.pk_entry_sv = StringVar()
self.pk_entry = Entry(dbcontrolpanel,textvariable=self.pk_entry_sv)
self.pk_entry.grid(column=12,row=1,sticky=NSEW)
self.pk_entry.focus_get()
self.pk_entry_sv.set("__id")
# last query row count
self.lastquery_rowcount_label = Label(dbcontrolpanel,text="last row#",width=10)
self.lastquery_rowcount_label.grid(column=13,row=1,sticky=NSEW)
self.lastquery_rowcount_label.focus_get()
self.lastquery_rowcount_text_sv = StringVar()
self.lastquery_rowcount_text = Entry(dbcontrolpanel,text=self.lastquery_rowcount_text_sv)
self.lastquery_rowcount_text.grid(column=14,row=1,sticky=NSEW)
self.lastquery_rowcount_text.focus_get()
# last query viewer
self.lastquery_label = Label(dbcontrolpanel,text="last query",width=10)
self.lastquery_label.grid(column=11,row=2,sticky=NSEW)
self.lastquery_label.focus_get()
self.lastquery_text_sv = StringVar()
self.lastquery_text = Entry(dbcontrolpanel,textvariable=self.lastquery_text_sv)
self.lastquery_text.grid(column=12,row=2,sticky=NSEW,columnspan=3)
self.lastquery_text.focus_get()
# controlpanel
controlpanel = Frame(self)
controlpanel.grid(row=3,column=1,sticky=NSEW,pady=10,padx=10)
self.scrolldelta_label = Label(controlpanel,text="sdelta",width=10)
self.scrolldelta_label.grid(column=0,row=0,sticky=NSEW)
self.scrolldelta_label.focus_get()
self.scrolldelta_label_entry_sv = StringVar()
self.scrolldelta_label_entry = Entry(controlpanel,textvariable=self.scrolldelta_label_entry_sv)
self.scrolldelta_label_entry.grid(column=1,row=0,sticky=NSEW)
self.scrolldelta_label_entry.focus_get()
self.scrolldelta_label_entry_sv.set(10)
self.hlightpk_label = Label(controlpanel,text="hlight pk",width=10)
self.hlightpk_label.grid(column=2,row=0,sticky=NSEW)
self.hlightpk_label.focus_get()
self.hlightpk_text_sv = StringVar()
self.hlightpk_text = Entry(controlpanel,text=self.hlightpk_text_sv)
self.hlightpk_text.grid(column=3,row=0,sticky=NSEW)
self.hlightpk_text.focus_get()
self.inputmode_label = Label(controlpanel,text="hlight pk",width=10)
self.inputmode_label.grid(column=4,row=0,sticky=NSEW)
self.inputmode_label.focus_get()
self.inputmode_value_sv = StringVar()
self.inputmode_value = Entry(controlpanel,width=10,textvariable=self.inputmode_value_sv)
self.inputmode_value.grid(row=0,column=5)
self.inputmode_value.focus_get()
self.inputmode_value_sv.set("NORMAL")
self.clipboard_size_label = Label(controlpanel,text="hlight pk",width=10)
self.clipboard_size_label.grid(column=6,row=0,sticky=NSEW)
self.clipboard_size_label.focus_get()
self.clipboard_size_value_sv = StringVar()
self.clipboard_size_value= Entry(controlpanel,width=10,textvariable=self.clipboard_size_value_sv)
self.clipboard_size_value.grid(row=0,column=7)
self.clipboard_size_value.focus_get()
self.clipboard_size_value_sv.set(0)
self.clipboard_selected_label = Label(controlpanel,text="hlight pk",width=10)
self.clipboard_selected_label.grid(column=8,row=0,sticky=NSEW)
self.clipboard_selected_label.focus_get()
self.clipboard_selected_value_sv = StringVar()
self.clipboard_selected_value= Entry(controlpanel,width=10,textvariable=self.clipboard_selected_value_sv)
self.clipboard_selected_value.grid(row=0,column=9)
self.clipboard_selected_value.focus_get()
self.clipboard_selected_value_sv.set(self.clipboard_selection)
# buttoncontrolpanel
buttoncontrolpanel = Frame(self)
buttoncontrolpanel.grid(row=4,column=1,sticky=NSEW,pady=10,padx=10)
self.dbload_button = Button(buttoncontrolpanel,command=self.load,text="dbload",name="dbl")
self.dbload_button.grid(column=0,row=1,sticky=NSEW)
self.dbload_button.focus_get()
self.clear_button = Button(buttoncontrolpanel,command=self.clear,text="clear",name="clr")
self.clear_button.grid(column=1,row=1,sticky=NSEW)
self.clear_button.focus_get()
self.dbinsert_button = Button(buttoncontrolpanel,command=self.insert,text="dbinsert",name="dbi")
self.dbinsert_button.grid(column=2,row=1,sticky=NSEW)
self.dbinsert_button.focus_get()
self.dbsavechanges_button = Button(buttoncontrolpanel,command=self.process_updates,text="dbsavechgs",name="dbc")
self.dbsavechanges_button.grid(column=3,row=1,sticky=NSEW)
self.dbsavechanges_button.focus_get()
self.clone_button = Button(buttoncontrolpanel,command=self.clone,text="clone",name="cln")
self.clone_button.grid(column=4,row=1,sticky=NSEW)
self.clone_button.focus_get()
self.delrow_button = Button(buttoncontrolpanel,command=self.delrow,text="delrow",name="drw")
self.delrow_button.grid(column=5,row=1,sticky=NSEW)
self.delrow_button.focus_get()
self.pagedown_button = Button(buttoncontrolpanel,
command=lambda: self.pagescroll('down'),
text="DOWN",name="pgd")
self.pagedown_button.grid(row=1,column=6,sticky=NSEW)
self.pagedown_button.focus_get()
self.pageup_button = Button(buttoncontrolpanel,
command=lambda: self.pagescroll('up'),
text="UP",name="pgu")
self.pageup_button.grid(row=1,column=7,sticky=NSEW)
self.pageup_button.focus_get()
self.pageleft_button = Button(buttoncontrolpanel,
command=lambda: self.pagescroll('left'),
text="LEFT",name="pgl")
self.pageleft_button.grid(row=1,column=8,sticky=NSEW)
self.pageleft_button.focus_get()
self.pageright_button = Button(buttoncontrolpanel,
command=lambda: self.pagescroll('right'),
text="RIGHT",name="pgr")
self.pageright_button.grid(row=1,column=9,sticky=NSEW)
self.pageright_button.focus_get()
self.hlightpk_button = Button(buttoncontrolpanel,width=1,command=self.delrow_show,
text="PK",name="hlpk")
self.hlightpk_button.grid(row=1,column=10,sticky=NSEW)
self.hlightpk_button.focus_get()
# new row grid x label
xlbl_widget_args=dict(width=10,font=font)
xlbl_widgetcfg = nxnarraycreate(self.maxrows,self.maxcols,xlbl_widget_args)
#mytruefalse = TrueFalse(name='truefalse')
mytextalphanum = TextAlphaNum(name='textalphanum')
mytextalphanum.widgettype = TkGridEntry
#self.newrowgridxlabel = TkImageLabelGrid(self,'entrygridxlbl',mytruefalse,2,wmheight,
# 0,0,self.maxrows,1,False,False,{},xlbl_widgetcfg)
self.newrowgridxlabel = TkImageLabelGrid(self,'entrygridxlbl',mytextalphanum,2,wmheight,
0,0,self.maxrows,1,False,False,{},xlbl_widgetcfg)
self.newrowgridxlabel.grid(row=5,column=0,rowspan=1,sticky=NS)
for i in range(self.maxrows):
self.newrowgridxlabel.widgets[i][0].sv.set(i+1)
self.newrowgridxlabel.widgets[i][0]['style'] = 'InFocus.Label.TEntry'
# new row grid
self.maxnewrows=maxnewrowrows
self.newrowgrid = TkImageLabelGrid(self,'newrowgrid',mytextalphanum,wmwidth,wmheight,
0,0,self.maxnewrows,self.maxcols,
False,False,{},widgetcfg)
self.newrowgrid.grid(row=5,column=1,sticky=NSEW)
self.grid_columnconfigure(0, weight=1, uniform="foo")
self.grid_columnconfigure(1, weight=25, uniform="foo")
self.grid_rowconfigure(0, weight=1, uniform="foo")
self.grid_rowconfigure(1, weight=15,uniform="foo")
self.grid_rowconfigure(5, weight=10, uniform="foo")
buttoncontrolpanel.grid_rowconfigure(0, weight=1, uniform="foo")
for i in range(10):
buttoncontrolpanel.grid_columnconfigure(i, weight=1, uniform="foo")
#controlpanel.grid_rowconfigure(0, weight=1, uniform="foo")
#for i in range(7):
# controlpanel.grid_columnconfigure(i, weight=1, uniform="foo")
def delrow_show(self):
l=[]
for i in range(self.maxrows):
if i <> 0:
widget = self.entrygridxlabel.widgets[i][0]
if widget['style'] == widget.style_on:
pk_id = self.pk_entry_sv.get()
pk_id_index = self.colnames.index(pk_id)
pkval = self.entrygrid.widgets[i-1][pk_id_index].sv.get()
l.append(pkval)
self.hlightpk_text_sv.set(",".join(l))
return(l)
def delrow(self):
database = Database(self.dbname_entry_sv.get())
for i in range(self.maxrows):
if i <> 0:
widget = self.entrygridxlabel.widgets[i][0]
if widget['style'] == widget.style_on:
pk_id = self.pk_entry_sv.get()
pk_id_index = self.colnames.index(pk_id)
pkval = self.entrygrid.widgets[i-1][pk_id_index].sv.get()
with database:
exec_str = tbl_row_delete(database,self.tblname_entry_sv.get(),
[[pk_id,"=","\""+pkval+"\""]])
self.lastquery_text_sv.set(exec_str)
self.clear()
self.load()
def deleteflagset(self,event=None):
print self.focus_get()
#print event.widget
def pagescroll(self,direction):
delta = int(self.scrolldelta_label_entry_sv.get())
invdelta = int(delta*-1)
if direction == "down":
self.entrygrid.canvas.yview("scroll",delta,"units")
self.entrygridxlabel.canvas.yview("scroll",delta,"units")
elif direction == "up":
self.entrygrid.canvas.yview("scroll",invdelta,"units")
self.entrygridxlabel.canvas.yview("scroll",invdelta,"units")
elif direction == "left":
self.entrygrid.canvas.xview("scroll",invdelta,"units")
self.entrygridylabel.canvas.xview("scroll",invdelta,"units")
elif direction == "right":
self.entrygrid.canvas.xview("scroll",delta,"units")
self.entrygridylabel.canvas.xview("scroll",delta,"units")
#self.entrygridxlabel.canvas.yview("scroll",10,"units")
#self.entrygridxlabel.canvas.xview("scroll",10,"units")
def pagedown(self):
self.entrygrid.canvas.yview("scroll",10,"units")
@logger(log)
def widget_current_values_get(self,gridname,rownum):
return sswizard_utils.widget_current_values_get(self,gridname,rownum)
def update_callback(self,widget,new_value):
sswizard_utils.update_callback(self,widget,new_value)
@logger(log)
def clone(self):
for y in range(self.maxcols):
colname = self.entrygrid.widgets[0][y].sv.get()
value = self.entrygrid.widgets[int(self.clone_entry_sv.get())][y].sv.get()
if colname <> "" and colname.startswith("_") == False:
self.newrowgrid.widgets[1][y].sv.set(value)
'''def _clear_entrygrid(self):
for x in range(self.maxrows):
for y in range(self.maxcols):
self.entrygrid.widgets[x][y].sv.set("")
self.entrygrid.widgets[x][y].config(background='white')
def _clear_newrowgrid(self,preserveheader=False):
firstrow=0
if preserveheader == True:
firstrow=1
for x in range(firstrow,self.maxnewrows):
for y in range(self.maxcols):
self.newrowgrid.widgets[x][y].sv.set("")
self.newrowgrid.widgets[x][y].config(background='white')'''
@logger(log)
def _clear_grid(self,gridname,firstrow):
grid = getattr(self,gridname)
for key in self.updates.keys():
row=[]
_gridname,x,y = key.split(",")
x = int(x)
y = int(y)
if gridname == _gridname:
grid.widgets[x][y].sv.set("")
grid.widgets[x][y].config(background='white')
grid.widgets[x][y].init_value = ""
grid.widgets[x][y].current_value = ""
grid.widgets[x][y].version = 0
#for x in range(firstrow,grid.maxrows):
# for y in range(grid.maxcols):
# grid.widgets[x][y].sv.set("")
# grid.widgets[x][y].config(background='white')
# grid.widgets[x][y].init_value = ""
# grid.widgets[x][y].current_value = ""
# grid.widgets[x][y].version = 0
@logger(log)
def clear(self,firstrow=0,gridname=None):
if gridname == None:
self._clear_grid('entrygrid',firstrow)
self._clear_grid('newrowgrid',firstrow)
else:
self._clear_grid(gridname,firstrow)
self.updates={}
@logger(log)
def focus_next_widget(self,event):
#nextwidget = self.master.tk_focusNext()
if str(event.widget)[-3:] == "svb":
self.entrygrid.focus()
else:
self.save_button.focus_set()
return("break")
@logger(log)
def process_updates(self,database=None):
if database == None:
database = Database(self.dbname_entry_sv.get())
pkcolnum = self.dbcol_defn.index(self.pk_entry_sv.get())
rows=[]
if len(self.updates.keys()) == 0:
log.log(thisfuncname(),3,"wierd","len(updates)=0")
for key in self.updates.keys():
row=[]
gridname,x,y = key.split(",")
# newrowgrid updates processed by insert; at some point
# add a flag to grid constructor as to whether or not it
# needs to put updates on the update queue
if gridname == "entrygrid":
colname = self.entrygrid.widgets[0][int(y)].sv.get()
new_value,version = self.updates[key]
# ignore any updates that are initial version (version=1)
if int(x)==0:
init_value = getattr(self,gridname).widgets[0][int(y)].init_value
current_value = getattr(self,gridname).widgets[0][int(y)].current_value
#new_value = getattr(self,gridname).widgets[0][int(y)].sv.get()
if new_value <> current_value:
log.log(thisfuncname(),3,msg="update_required",y=y,x=x,colname=colname,key=key)
if init_value == "":
with database:
try:
tbl_col_add(database,
self.tblname_entry_sv.get(),
new_value)
log.log(thisfuncname(),4,func=tbl_col_add,current_value=current_value,new_value=new_value)
getattr(self,gridname).widgets[0][int(y)].version += 1
except Exception,e:
log.log(thisfuncname(),1,func=tbl_col_add,error=str(e))
else:
#try:
with database:
tbl_col_update(database,
self.tblname_entry_sv.get(),
current_value,
new_value)
log.log(thisfuncname(),4,func=tbl_col_update,current_value=current_value,new_value=new_value)
#except Exception,e:
#log.log(thisfuncname(),1,func=tbl_col_update,error=str(e))
getattr(self,gridname).widgets[0][int(y)].current_value = new_value
else:
log.log(thisfuncname(),3,msg="ignoring as values have not changed",current_value=current_value,new_value=new_value)
else:
pkval = self.entrygrid.widgets[int(x)][pkcolnum].sv.get()
# ignore updates that are not different from init_value
# could be changed and then changed back or could be just inital load
if str(new_value) <> str(self.entrygrid.widgets[int(x)][int(y)].current_value):
try:
new_value = int(new_value)
except:
new_value = "\""+new_value+"\""
_row= [colname,new_value,self.pk_entry_sv.get(),"\""+pkval+"\""]
rows.append(_row)
log.log(thisfuncname(),3,msg="add to dbupdate queue",x=x,y=y,colname=colname,new_value=new_value,pkval=pkval)
self.entrygrid.widgets[int(x)][int(y)].current_value = new_value
self.entrygrid.widgets[int(x)][int(y)].version += 1
with database:
for row in rows:
try:
exec_str,result = tbl_rows_update(database,self.tblname_entry_sv.get(),
row)
log.log(thisfuncname(),4,func=tbl_rows_update,exec_str=exec_str,result=str(result))
except Exception,e:
log.log(thisfuncname(),1,func=tbl_rows_update,error=str(e))
def verbosity_set(self,new_value):
self.log(thisfuncname(),3,msg="updating verbosity",old_value = self.verbosity,new_value = new_value)
self.verbosity = new_value
exception=e,
msg=e.message,
tblname=tblname,
fldname=fldname)
enums[tblname] = {}
#name2code = dict((row[0],row[1]) for row in values)
# explicit loop as OrderedDict only keeps order when items are added after initialization
name2code = OrderedDict()
name2enum = OrderedDict()
code2enum = OrderedDict()
for k, v, e in values:
if v == 'None' or e == None:
log.log(thisfuncname(),
1,
msg="none value detected",
tblname=tblname,
key=str(k))
continue
name2code[k] = v
name2enum[k] = int(e)
code2enum[v] = int(e)
# unknown/none is represented with '??'
name2code['??'] = '??'
enums[tblname]['name2code'] = name2code
enums[tblname]['code2name'] = dict(
def dropdown_build(database,
widgetargs,
exec_func,
prep,
dow="Monday",
rowheaderexecfunc=None,
columnheaderexecfunc=None,
ui=None):
xoffset = 0
yoffset = 0
log.log(thisfuncname(),
3,
msg="creating dropdowns lists",
dow=dow,
prep=prep)
# if not creating dropdowns for the headers increment the count
if rowheaderexecfunc == None: yoffset = 1
if columnheaderexecfunc == None: xoffset = 1
output = []
with database:
for y in range(yoffset, len(widgetargs[0])):
colndefn, values, exec_str = exec_func(database, y, prep, dow)
# pull out distinct and make a single list
values = [value[0] for value in values]
values = list(set(values))
# add a 'values' attr for each widget
for x in range(xoffset, len(widgetargs)):
widgetargs[x][y]['values'] = values
log.log(thisfuncname(),
10,
msg="generated data dropdowns",
num=len(values),
query=exec_str)
if rowheaderexecfunc <> None:
colndefn, values, exec_str = rowheaderexecfunc(
database, "prep", prep)
values = [value[0] for value in values]
for x in range(len(widgetargs)):
widgetargs[x][0]['values'] = values
if ui <> None:
ui.widgets[x][0].sv.set(values[x])
log.log(thisfuncname(),
10,
msg="generated row hdr dropdowns",
num=len(values),
query=exec_str)
if columnheaderexecfunc <> None:
colndefn, values, exec_str = columnheaderexecfunc(database)
values = [value[0] for value in values]
for y in range(len(widgetargs[0])):
widgetargs[0][y]['values'] = values
if ui <> None:
ui.widgets[0][y].sv.set(values[y])
log.log(thisfuncname(),
10,
msg="generated col hdr dropdowns",
num=len(values),
query=exec_str)
return (widgetargs)
def session_code_gen(dbname, dryrun=False):
database = Database(dbname)
exec_str = "select s.name,lt.code || '.' || s.code"
exec_str += " from subject as s,lessontype as lt"
exec_str += " where s.lessontype = lt.name"
with database:
colnames, rows = tbl_query(database, exec_str)
subject_lookup = dict((row[0], row[1]) for row in rows)
exec_str = "select teacher,subject,__id,code,type,day from session"
with database:
colnames, rows = tbl_query(database, exec_str)
enums = setenums('All', '-1', database)
for row in rows:
teacher = row[0]
subject = row[1]
__id = row[2]
oldcode = row[3]
lessontype = row[4]
dow = row[5]
if dow == None:
dow = "??"
if teacher == None:
teacher_code = "??"
lessontype_code = "??"
if lessontype == "WP":
lessontype_code = "WP"
if subject == None:
subject_code = lessontype_code + ".??"
elif subject_lookup.has_key(subject) == False:
subject_code = lessontype_code + ".??"
else:
subject_code = subject_lookup[subject]
teacher_code = enums['adult']['name2code'][teacher]
#session_code = ".".join([teacher_code,subject_code,])
dow_code = enums['dow']['name2code'][dow]
session_code = ".".join([teacher_code, subject_code, dow_code])
if oldcode <> session_code:
with database:
exec_str, _ = tbl_rows_update(
database,
'session', [
'code', "\"" + session_code + "\"", '__id',
"\"" + __id + "\""
],
dryrun=dryrun)
print exec_str, oldcode
log.log(thisfuncname(),
4,
msg="session code updated",
execstr=exec_str,
oldcode=oldcode)
output_row.append(" ".join(output_cell))
else:
output_row.append(str(item))
outputstr += "^".join(output_row) + "\n"
return outputstr
if __name__ == "__main__":
enableui = True
if len(sys.argv) <= 1:
raise Exception("provide a database name; no extension")
else:
log.log(thisfuncname(), 3, msg="using database", database=sys.argv[1])
try:
if sys.argv[2] == "True":
enableui = True
except:
pass
of = ObjFactory(True)
app = WizardUI(sys.argv[1],
of,
sys.argv[1],
maxentrycols=12,
maxentryrows=20)
conflicts_only = "Y"
def __init__(self,
dbname,
of,
refdbname,
maxentrycols=3,
maxentryrows=4,
maxnewrowcols=3,
maxnewrowrows=3):
log.log(thisfuncname(),
3,
msg="initialize",
dbname=dbname,
refdbname=refdbname)
#sys.platform == "darwin":
#self.clipboard=[]
#self.clipboard_selection=-1
Tk.__init__(self)
try:
globals()['colors'] = dbcolors_get(dbname)
self.colorpalette = dbformats_get(dbname, 'bgcolor')
self.fontpalette = dbformats_get(dbname, 'fgcolor')
except:
pass
#self.colorpalette = colorpalette
#self.fontpalette = fontpalette
screenwidth = self.winfo_vrootwidth()
screenheight = self.winfo_vrootheight()
self.geometry(str(screenwidth) + "x" + str(screenheight) + "+0+0")
wx = 8
self.refdatabase = Database(refdbname)
#self.enums = sswizard_utils.setenums('All','5',self.refdatabase)
self.dbname = dbname
self.database = Database(self.dbname)
self.of = of
font = tkFont.Font(family="monospace", size=9)
self.font = font
self.lastsaveversion = 0
style = Style()
#bigfont = tkFont.Font(family="Helvetica",size=50)
#self.option_add("*TCombobox*Listbox*Font", bigfont)
self.current_inputmode = "Normal"
set_configs(style)
# any children that change update this
# key is the name and value is the new val
# the name is likely to be the tkwidgetid.x,y
self.updates = OrderedDict()
self.maxrows = maxentryrows # rows in the grid
self.maxcols = maxentrycols # cols in the grid
maxwidgets = self.maxrows * self.maxcols
wwidth = 48 # default button width with text of 3 chars
wheight = 29 # default button height
wmheight = wheight * self.maxrows # master height
wmwidth = wwidth * self.maxcols # master width
style.configure('ControlPanel.TFrame', background='lightgrey')
controlpanel = Frame(self, style='ControlPanel.TFrame')
controlpanel.grid(row=1, column=0, sticky=NSEW, columnspan=2)
self.dbload_entry_label = Label(controlpanel,
text="version",
width=wx,
font=font,
anchor=E)
self.dbload_entry_label.grid(row=0, column=1, pady=5)
self.dbload_entry_label.focus_get()
self.dbload_entry_sv = StringVar()
self.dbload_entry = Entry(controlpanel,
textvariable=self.dbload_entry_sv,
width=wx,
font=font)
self.dbload_entry.grid(row=0, column=2, pady=5)
self.dbload_entry_sv.set('1')
self.dbload_entry.focus_get()
self.dbname_entry_label = Label(controlpanel,
text="dbname",
width=wx,
font=font,
anchor=E)
self.dbname_entry_label.grid(row=0, column=3, pady=5)
self.dbname_entry_label.focus_get()
self.dbname_entry_sv = StringVar()
self.dbname_entry = Entry(controlpanel,
textvariable=self.dbname_entry_sv,
width=wx,
font=font)
self.dbname_entry.grid(row=0, column=4, pady=5)
self.dbname_entry.focus_get()
self.dbname_entry_sv.set(self.dbname)
self.dow_entry_label = Label(controlpanel,
text="dow",
width=wx,
font=font,
anchor=E)
self.dow_entry_label.grid(row=0, column=5, pady=5)
self.dow_entry_label.focus_get()
self.dow_entry_sv = StringVar()
self.dow_entry = Entry(controlpanel,
textvariable=self.dow_entry_sv,
width=wx,
font=font)
self.dow_entry.grid(row=0, column=6, pady=5)
self.dow_entry.focus_get()
#self.dow_entry_sv.set('MO')
self.prep_label = Label(controlpanel,
text="prep",
width=wx,
font=font,
anchor=E)
self.prep_label.grid(row=0, column=7, pady=5)
self.prep_label.focus_get()
self.prep_entry_sv = StringVar()
self.prep_entry = Entry(controlpanel,
textvariable=self.prep_entry_sv,
width=wx,
font=font)
self.prep_entry.grid(row=0, column=8, pady=5)
self.prep_entry.focus_get()
#self.prep_entry_sv.set(5)
self.period_label = Label(controlpanel,
text="period",
width=wx,
font=font,
anchor=E)
self.period_label.grid(row=0, column=9, pady=5)
self.period_label.focus_get()
self.period_entry_sv = StringVar()
self.period_entry = Entry(controlpanel,
textvariable=self.period_entry_sv,
width=wx,
font=font)
self.period_entry.grid(row=0, column=10, pady=5)
self.period_entry.focus_get()
#self.period_entry_sv.set('830-910')
self.teacher_label = Label(controlpanel,
text="teacher",
width=wx,
font=font,
anchor=E)
self.teacher_label.grid(row=0, column=11, pady=5)
self.teacher_label.focus_get()
self.teacher_label_sv = StringVar()
self.teacher_label = Entry(controlpanel,
textvariable=self.teacher_label_sv,
width=wx,
font=font)
self.teacher_label.grid(row=0, column=12, pady=5)
self.teacher_label.focus_get()
#self.teacher_label_sv.set('Stan')
self.student_label = Label(controlpanel,
text="student",
width=wx,
font=font,
anchor=E)
self.student_label.grid(row=0, column=13, pady=5)
self.student_label.focus_get()
self.student_label_sv = StringVar()
self.student_label = Entry(controlpanel,
textvariable=self.student_label_sv,
width=wx,
font=font)
self.student_label.grid(row=0, column=14, pady=5)
self.student_label.focus_get()
self.student_label_sv.set('Nathaniel')
self.source_label = Label(controlpanel,
text="source",
width=wx,
font=font,
anchor=E)
self.source_label.grid(row=0, column=15, pady=5)
self.source_label.focus_get()
self.source_label_sv = StringVar()
self.source_label = Entry(controlpanel,
textvariable=self.source_label_sv,
width=wx,
font=font)
self.source_label.grid(row=0, column=16, pady=5)
self.source_label.focus_get()
self.source_label_sv.set('dbinsert')
self.unknown_checkbutton_sv = StringVar()
self.unknown_checkbutton = _checkbutton(
controlpanel,
text="unknowns",
variable=self.unknown_checkbutton_sv,
onvalue="Y",
offvalue="N",
width=wx * 2,
font=font)
self.unknown_checkbutton.grid(row=0, column=17, pady=5)
buttonpanel = Frame(controlpanel, style='ControlPanel.TFrame')
buttonpanel.grid(row=0, column=18, sticky=NSEW)
self.dbload_button = _tkbutton(
buttonpanel,
font=font,
command=lambda: self.load(self.dbload_entry_sv.get()),
text="dbload",
name="dbl")
self.dbload_button.grid(row=0, column=0, pady=5)
self.dbload_button.focus_get()
self.clear_button = _tkbutton(buttonpanel,
font=font,
command=self.clear,
text="clear",
name="clr")
self.clear_button.grid(row=0, column=1, pady=5)
self.clear_button.focus_get()
self.viewer_button = _tkbutton(buttonpanel,
font=font,
command=self.viewer,
text="viewer",
name="view")
self.viewer_button.grid(row=0, column=2, pady=5)
self.viewer_button.focus_get()
self.viewcontrolpanel = Frame(self.master)
self.viewcontrolpanel.grid(row=2, column=0, sticky=NSEW)
self.viewxaxis_label = Label(self.viewcontrolpanel,
text="xaxis",
width=wx,
font=font,
anchor=E)
self.viewxaxis_label.grid(row=0, column=0, pady=5)
self.viewxaxis_label.focus_get()
self.viewxaxis_label_sv = StringVar()
self.viewxaxis_label = Entry(self.viewcontrolpanel,
textvariable=self.viewxaxis_label_sv,
width=wx,
font=font)
self.viewxaxis_label.grid(row=0, column=1, pady=5)
self.viewxaxis_label.focus_get()
self.viewxaxis_label_sv.set("period")
self.viewyaxis_label = Label(self.viewcontrolpanel,
text="yaxis",
width=wx,
font=font,
anchor=E)
self.viewyaxis_label.grid(row=0, column=2, pady=5)
self.viewyaxis_label.focus_get()
self.viewyaxis_label_sv = StringVar()
self.viewyaxis_label = Entry(self.viewcontrolpanel,
textvariable=self.viewyaxis_label_sv,
width=wx,
font=font)
self.viewyaxis_label.grid(row=0, column=3, pady=5)
self.viewyaxis_label.focus_get()
self.viewyaxis_label_sv.set("dow")
self.viewfocus_label = Label(self.viewcontrolpanel,
text="focus",
width=wx,
font=font,
anchor=E)
self.viewfocus_label.grid(row=0, column=4, pady=5)
self.viewfocus_label.focus_get()
self.viewfocus_label_sv = StringVar()
self.viewfocus_label = Entry(self.viewcontrolpanel,
textvariable=self.viewfocus_label_sv,
width=wx * 2,
font=font)
self.viewfocus_label.grid(row=0, column=5, pady=5)
self.viewfocus_label.focus_get()
self.viewfocus_label_sv.set("student=Nathaniel")
self.viewstudent_label = Label(self.viewcontrolpanel,
text="student",
width=wx,
font=font,
anchor=E)
self.viewstudent_label.grid(row=0, column=6, pady=5)
self.viewstudent_label.focus_get()
self.viewstudent_label_sv = StringVar()
self.viewstudent_label = Entry(self.viewcontrolpanel,
textvariable=self.viewstudent_label_sv,
width=wx,
font=font)
self.viewstudent_label.grid(row=0, column=7, pady=5)
self.viewstudent_label.focus_get()
self.viewstudent_label_sv.set("Nathaniel")
self.viewteacher_label = Label(self.viewcontrolpanel,
text="dow",
width=wx,
font=font,
anchor=E)
self.viewteacher_label.grid(row=0, column=8, pady=5)
self.viewteacher_label.focus_get()
self.viewteacher_label_sv = StringVar()
self.viewteacher_label = Entry(self.viewcontrolpanel,
textvariable=self.viewteacher_label_sv,
width=wx,
font=font)
self.viewteacher_label.grid(row=0, column=9, pady=5)
self.viewteacher_label.focus_get()
self.viewdata_label = Label(self.viewcontrolpanel,
text="data",
width=wx,
font=font,
anchor=E)
self.viewdata_label.grid(row=0, column=10, pady=5)
self.viewdata_label.focus_get()
self.viewdata_label_sv = StringVar()
self.viewdata_label = Entry(self.viewcontrolpanel,
textvariable=self.viewdata_label_sv,
width=wx * 3,
font=font)
self.viewdata_label.grid(row=0, column=11, pady=5)
self.viewdata_label.focus_get()
self.viewdata_label_sv.set("subject,teacher,recordtype")
self.wheight_label = Label(self.viewcontrolpanel,
text="wheight",
width=wx,
font=font,
anchor=E)
self.wheight_label.grid(row=0, column=12, pady=5)
self.wheight_label.focus_get()
self.wheight_label_sv = StringVar()
self.wheight_label = Entry(self.viewcontrolpanel,
textvariable=self.wheight_label_sv,
width=wx,
font=font)
self.wheight_label.grid(row=0, column=13, pady=5)
self.wheight_label.focus_get()
self.wheight_label_sv.set(1)
self.conflict_checkbutton_sv = StringVar()
self.conflict_checkbutton = _checkbutton(
self.viewcontrolpanel,
text="conflicts only",
variable=self.conflict_checkbutton_sv,
onvalue="Y",
offvalue="N",
width=wx * 2,
font=font)
self.conflict_checkbutton.grid(row=0, column=14, pady=5)
self.wratio_label = Label(self.viewcontrolpanel,
text="wratio",
width=wx,
font=font,
anchor=E)
self.wratio_label.grid(row=0, column=15, pady=5)
self.wratio_label.focus_get()
self.wratio_label_sv = StringVar()
self.wratio_label = Entry(self.viewcontrolpanel,
textvariable=self.wratio_label_sv,
width=wx,
font=font)
self.wratio_label.grid(row=0, column=16, pady=5)
self.wratio_label.focus_get()
self.wratio_label_sv.set("1,1,1")
self.grid_columnconfigure(0, weight=1, uniform="foo")
def dataset_pivot(of,
enums,
yaxis_type,
xaxis_type,
ztypes,
source_type,
source_value,
conflicts_only='N',
constraints=None,
wratio=None,
formatson=False,
rollupson=False):
''' query in memory objects; pivot data and create a table of results; return in 2d array '''
log.log(thisfuncname(),
3,
yaxis_type=yaxis_type,
xaxis_type=xaxis_type,
ztypes=ztypes,
source_type=source_type,
source_value=source_value,
conflicts_only=conflicts_only,
constraints=constraints,
wratio=wratio,
formatson=formatson,
rollupson=rollupson)
if source_value == "":
source_objs = of.query(source_type)
else:
source_objs = [of.object_get(source_type, source_value)]
xaxis_obj = of.query(xaxis_type)
yaxis_obj = of.query(yaxis_type)
count = 1
# uncomment here to make DOW's present in order
yaxis_enum = OrderedDict()
#yaxis_enum = {}
for _yaxis_obj in yaxis_obj:
yaxis_enum[_yaxis_obj.name] = count
count += 1
count = 1
xaxis_enum = OrderedDict()
#xaxis_enum = {}
for _xaxis_obj in xaxis_obj:
xaxis_enum[_xaxis_obj.name] = count
count += 1
# use these if want to drive pivot axes from ref table rather than the values
# used so far by actual objects
#xaxis_enum = enums[xaxis_type]['name2enum']
values = [] # contains the values displayed on the grid
values = [['']]
for yval in yaxis_enum.keys():
values[0].append(yval)
for xval in xaxis_enum.keys():
values.append([xval])
ymax = len(values[0])
xmax = len(values) - 1
def _additem(celltext, item):
if len(celltext) == 0:
celltext.append(item)
else:
try:
celltext.index(item)
except:
celltext.append(item)
return (celltext)
for yval, y in yaxis_enum.iteritems():
for xval, x in xaxis_enum.iteritems():
celltext = []
for source_obj in source_objs:
if source_obj.lessons.has_key(yval):
if source_obj.lessons[yval].has_key(xval):
_vals = source_obj.lessons[yval][xval]
for _val in _vals:
if constraints <> None and constraints <> []:
flag = False
for objtype, objval in constraints:
lobjvals = objval.split(",")
match = None
for lobjval in lobjvals:
if str(getattr(
_val,
objtype).name) <> str(lobjval):
if match <> False:
match = True
else:
match = False
if match == True:
flag = True
if flag == True:
continue
if ztypes == ['*']:
if celltext == []:
celltext.append(1)
else:
celltext[0] = celltext[0] + 1
continue
_celltext = []
for ztype in ztypes:
if hasattr(_val, ztype) == True:
zval = getattr(_val, ztype)
try:
_celltext.index(zval.name)
except:
if hasattr(zval, 'name'):
_celltext = _additem(
_celltext, zval.name)
else:
_celltext = _additem(
_celltext, zval)
pass
try:
celltext.index(tuple(_celltext))
except:
celltext.append(tuple(_celltext))
values[x].append(celltext)
sswizard_utils.gridreduce(values, [[]])
if rollupson == True:
sswizard_utils.gridrollup(values, ['subject', 'adult'],
dict(ztypes='subject,adult,student'))
return values
def test_debug(self):
self.log.log(thisfuncname(),7)
logfile = os_file_to_list(self.log.logpath)
self.assertEquals(logfile[0].split("|")[2].strip(),"DEBUG")
def update(self, of, field, newvalue, dbname=None):
# this is needed to get around the sqlite limitation that
# an sqlite cursor can only be used in the thread it was instantiated in
if dbname <> None:
database = Database(dbname)
else:
database = self.database
# this is over writing the base class update
# these are hacks; and the datatypes id/adult need to be
# called the same thing internally all the time
# until then though ....
# remove the id field as its set on the object from the
# internal __id field for convenience but should not be repersisted
# as the database layer will create the new __id for any revisions
if hasattr(self, 'id') == True:
_oldidobj = getattr(self, 'id')
elif hasattr(self, '__id') == True:
_oldidobj = getattr(self, '__id')
else:
raise Exception("cannot find an ID field")
if hasattr(_oldidobj, "name") == True:
setattr(self, "__id", _oldidobj.name)
else:
setattr(self, "__id", _oldidobj)
delattr(self, 'id')
self.tbl_row_value_get(False)
self.tbl_col_defn_get(False)
self.tbl_name_get()
# and also
try:
_idx = self.tbl_col_names.index('adult')
self.tbl_col_names.remove('adult')
self.tbl_col_names.insert(0, 'teacher')
except:
pass
# and also objtype is not persisted
try:
_idx = self.tbl_col_names.index('objtype')
self.tbl_col_names.pop(_idx)
self.tbl_row_values[0].pop(_idx)
except:
pass
currentrecord = dict(zip(self.tbl_col_names, self.tbl_row_values[0]))
_id = IDGenerator().getid()
_ts = self._gettimestamp()
newrecord = deepcopy(currentrecord)
newrecord['__version'] = "\"current\""
newrecord[field] = "\"" + str(newvalue) + "\""
newrecord['__id'] = "\"" + _id + "\""
newrecord['saveversion'] = 1
newrecord['__timestamp'] = "\"" + _ts + "\""
#_newvalobj = of.object_get_byval(field,newvalue)
if currentrecord[field] <> newrecord[field]:
# create a new row in the database with version "current"
with database:
result, exec_str = tbl_rows_insert(database, self.tbl_name,
newrecord.keys(),
[newrecord.values()])
# update version of current row to version "version"
tbl_rows_update(database, self.tbl_name, [
'__version', "\"version\"", '__id',
"\"" + getattr(self, "__id") + "\""
])
# update in mem object to new val and new db version id and timestamp
# assumes that field is also an objects whose value is in the name attr
if field == "teacher":
field = "adult"
_newvalobj = of.object_get_byval(field, newvalue)
if _newvalobj == None:
log.log(thisfuncname(),
2,
msg="tryng to update to a value that does not exist",
field=field,
newvalue=newvalue)
return -1
#_oldobj = getattr(self,field)
#setattr(_oldobj,'name',newvalue)
setattr(self, field, _newvalobj)
# give the new updated record the same database ref id as prev version
if hasattr(_oldidobj, "name") == True:
#setattr(self,"__id",_oldidobj.name)
setattr(_oldidobj, "name", _id)
else:
#setattr(self,"__id",_oldidobj)
setattr(self, _oldidobj, _id)
#setattr(_oldidobj,"name",_id)
setattr(self, 'id', _oldidobj)
#setattr(self,'id',_id)
setattr(self, '__version', "current")
setattr(self, '__timestamp', _ts)
# update internal dm
_dm = getattr(self, "dm")
_dm[field] = newvalue
_dm['id'] = _id
setattr(self, "dm", _dm)
return _id
def test_extra_msg(self):
self.log.log(thisfuncname(),3,foobar='barfoo')
expected_results = "[('foobar','barfoo')]"
logfile = os_file_to_list(self.log.logpath)
self.assertEquals(logfile[0].split("|")[9].strip(),expected_results)
def process_updates(self,database=None):
if database == None:
database = Database(self.dbname_entry_sv.get())
pkcolnum = self.dbcol_defn.index(self.pk_entry_sv.get())
rows=[]
if len(self.updates.keys()) == 0:
log.log(thisfuncname(),3,"wierd","len(updates)=0")
for key in self.updates.keys():
row=[]
gridname,x,y = key.split(",")
# newrowgrid updates processed by insert; at some point
# add a flag to grid constructor as to whether or not it
# needs to put updates on the update queue
if gridname == "entrygrid":
colname = self.entrygrid.widgets[0][int(y)].sv.get()
new_value,version = self.updates[key]
# ignore any updates that are initial version (version=1)
if int(x)==0:
init_value = getattr(self,gridname).widgets[0][int(y)].init_value
current_value = getattr(self,gridname).widgets[0][int(y)].current_value
#new_value = getattr(self,gridname).widgets[0][int(y)].sv.get()
if new_value <> current_value:
log.log(thisfuncname(),3,msg="update_required",y=y,x=x,colname=colname,key=key)
if init_value == "":
with database:
try:
tbl_col_add(database,
self.tblname_entry_sv.get(),
new_value)
log.log(thisfuncname(),4,func=tbl_col_add,current_value=current_value,new_value=new_value)
getattr(self,gridname).widgets[0][int(y)].version += 1
except Exception,e:
log.log(thisfuncname(),1,func=tbl_col_add,error=str(e))
else:
#try:
with database:
tbl_col_update(database,
self.tblname_entry_sv.get(),
current_value,
new_value)
log.log(thisfuncname(),4,func=tbl_col_update,current_value=current_value,new_value=new_value)
#except Exception,e:
#log.log(thisfuncname(),1,func=tbl_col_update,error=str(e))
getattr(self,gridname).widgets[0][int(y)].current_value = new_value
else:
log.log(thisfuncname(),3,msg="ignoring as values have not changed",current_value=current_value,new_value=new_value)
else:
pkval = self.entrygrid.widgets[int(x)][pkcolnum].sv.get()
# ignore updates that are not different from init_value
# could be changed and then changed back or could be just inital load
if str(new_value) <> str(self.entrygrid.widgets[int(x)][int(y)].current_value):
try:
new_value = int(new_value)
except:
new_value = "\""+new_value+"\""
_row= [colname,new_value,self.pk_entry_sv.get(),"\""+pkval+"\""]
rows.append(_row)
log.log(thisfuncname(),3,msg="add to dbupdate queue",x=x,y=y,colname=colname,new_value=new_value,pkval=pkval)
self.entrygrid.widgets[int(x)][int(y)].current_value = new_value
self.entrygrid.widgets[int(x)][int(y)].version += 1
try:
coldefn,values,_ = tbl_query(database,exec_str)
except DBException, e:
log.log(thisfuncname(),0,exception=e,msg=e.message,tblname=tblname,fldname=fldname)
enums[tblname] = {}
#name2code = dict((row[0],row[1]) for row in values)
# explicit loop as OrderedDict only keeps order when items are added after initialization
name2code = OrderedDict()
name2enum = OrderedDict()
code2enum = OrderedDict()
for k,v,e in values:
if v == 'None' or e == None:
log.log(thisfuncname(),1,msg="none value detected",tblname=tblname,key=str(k))
continue
name2code[k] = v
name2enum[k] = int(e)
code2enum[v] = int(e)
# unknown/none is represented with '??'
name2code['??'] = '??'
enums[tblname]['name2code'] = name2code
enums[tblname]['code2name'] = dict(zip(name2code.values(),name2code.keys()))
#enums[tblname]['name2enum'] = dict((value,enum) for enum,value in enumerate(name2code.keys()))
#enums[tblname]['code2enum'] = dict((value,enum) for enum,value in enumerate(name2code.values()))
enums[tblname]['name2enum'] =name2enum
def load(self,afterinsert=False,values=None):
colwidths = []
if afterinsert==True:
# we dont need to reload the headers as this an update of existing table
self.clear(1)
database = Database(self.dbname_entry_sv.get())
whereclauses = []
if self.pred1_entry_sv.get() <> "":
whereclauses.append([self.pred1_entry_sv.get(),
self.pred1_op_entry_sv.get(),
self.predval1_entry_sv.get()])
log.log(thisfuncname(),9,msg="where clause specified",whereclauses=whereclauses)
if self.pred2_entry_sv.get() <> "":
whereclauses.append([self.pred2_entry_sv.get(),
self.pred2_op_entry_sv.get(),
self.predval2_entry_sv.get()])
log.log(thisfuncname(),9,msg="where clause specified",whereclauses=whereclauses)
if self.pred3_entry_sv.get() <> "":
whereclauses.append([self.pred3_entry_sv.get(),
self.pred3_op_entry_sv.get(),
self.predval3_entry_sv.get()])
log.log(thisfuncname(),9,msg="where clause specified",whereclauses=whereclauses)
with database:
colndefn,rows,exec_str = tbl_rows_get(database,self.tblname_entry_sv.get(),"*",whereclauses)
self.lastquery_text_sv.set(exec_str)
self.lastquery_rowcount_text_sv.set(str(len(rows)))
log.log(thisfuncname(),3,func=tbl_rows_get,msg=str(len(rows))+"rows loaded",table=self.tblname_entry_sv.get())
for y in range(len(colndefn)):
self.dbcol_defn.append(colndefn[y])
new_value = colndefn[y]
print y
self.entrygrid.widgets[0][y].sv.set(new_value)
self.entrygrid.widgets[0][y].current_value = new_value
self.newrowgrid.widgets[0][y].sv.set(new_value)
self.newrowgrid.widgets[0][y].current_value = new_value
# reset init_value for headers after we have loaded
# so we can determine a new column from an updated column
self.entrygrid.widgets[0][y].init_value = new_value
self.newrowgrid.widgets[0][y].init_value = new_value
print rows
#for x in range(len(rows)):
for x in range(self.maxrows-1): # 1 taken up for header
for y in range(len(rows[x])):
#try:
new_value = rows[x][y]
# current widget
widget = self.entrygrid.widgets[x+1][y]
# this is so the entry widgets can distinguish between
# nothing loaded and a space loaded
if new_value == "": new_value = "<SPACE>"
# +1 to avoid the header row
widget.sv.set(new_value)
widget.current_value = new_value
# and set the style back to not updated
widget['style'] = 'OutOfFocus.Notchanged.TEntry'
try:
if len(str(new_value)) > colwidths[y]:
colwidths[y]=len(str(new_value))
except IndexError:
colwidths.append(len(str(new_value)))
# after load store the column headers for easy lookup later
self.colnames = colndefn
for i in range(len(colwidths)):
self.entrygrid.canvasframe.grid_columnconfigure(i,weight=colwidths[i],uniform="foo")
self.newrowgrid.canvasframe.grid_columnconfigure(i,weight=colwidths[i],uniform="foo")
def load(self,saveversion, dow=None, prep=None, period=None, teacher=None, student=None, source=None,
unknown='N'):
self.of.reset()
whereclause = []
# unknown
if unknown=='N':
whereclause.append(['student',"<>","\"??\""])
whereclause.append(['subject',"<>","\"??\""])
whereclause.append(['teacher',"<>","\"??\""])
log.log(thisfuncname(),3,msg="loading",unknown=str(unknown))
# prep
if prep==None:
prep = -1
else:
whereclause.append(['prep',"=",prep])
log.log(thisfuncname(),3,msg="loading",prep=str(prep))
# period
if period==None:
prep = -1
else:
whereclause.append(['period',"=","\""+period+"\""])
log.log(thisfuncname(),3,msg="loading",prep=str(prep))
# dow
if dow==None:
dow = "all"
else:
whereclause.append( ['dow',"=","\""+dow+"\""])
log.log(thisfuncname(),3,msg="loading",dow=str(dow))
# teacher
if teacher==None:
teacher = "all"
else:
whereclause.append( ['teacher',"=","\""+teacher+"\""])
log.log(thisfuncname(),3,msg="loading",teacher=str(teacher))
# student
if student==None:
student = "all"
else:
whereclause.append( ['student',"=","\""+student+"\""])
log.log(thisfuncname(),3,msg="loading",student=str(student))
# source
if source==None:
source = "dbinsert"
else:
_sources = ["\"" + _source + "\"" for _source in source.split(",")]
whereclause.append( ['source',"in","("+",".join(_sources)+")"])
log.log(thisfuncname(),3,msg="loading",source=str(source))
# get enums
self.enums = sswizard_utils.setenums(dow,prep,self.refdatabase)
# load from database
cols = ['period','student','session','dow','teacher','subject','userobjid','status','substatus','recordtype','source']
with self.database:
colndefn,rows,exec_str = tbl_rows_get(self.database,'lesson',cols,whereclause)
log.log(thisfuncname(),9,msg="dbread",exec_str=exec_str)
cols = ['period','student','session','dow','adult','subject','userobjid','status','substatus','recordtype','source']
# parse rows
for row in rows:
datamembers = {}
for i in range(len(cols)):
datamembers[cols[i]] = row[i]
_,lessontype_code,_,_ = datamembers['session'].split(".")
#lessontype = self.enums['lessontype']['code2name'][lessontype_code]
datamembers['objtype'] = 'lesson'
lesson = self.of.new(schoolschedgeneric,'lesson',objid=datamembers['userobjid'],
constructor='datamembers',database=self.database,
of=self.of,modname=__name__,dm=datamembers)
self.lesson_change(lesson)
log.log(thisfuncname(),3,msg="loading row",dm=datamembers)
# post log with results
log.log(thisfuncname(),3,msg="db rows loaded",num=len(rows))
for i in range(len(cols)):
log.log(thisfuncname(),3,msg="lesson obj created",num=len(self.of.store[cols[i]]))
