def test_db(self):
expected_result = [[
u'Dylan', u'Clayton', u'1030-1110', u'MO', u'Game Period',
u'academic'
], [u'Stan', u'Nathaniel', u'830-910', u'TU', u'Math', u'academic']]
datamembers = {
'student': 'Nathaniel',
'teacher': 'Stan',
'subject': 'Math',
'period': '830-910',
'recordtype': 'academic',
'dow': 'Tuesday'
}
args = dict(database=self.database,
refdatabase=self.database,
prepmap=self.prepmap,
of=self.of,
enums=self.enums,
datamembers=datamembers)
obj = ssviewer_utils.dataset_add(**args)
obj.keepversion = True
obj.customtimestamp = "%y%m%d_%H%M%S"
with self.database:
_, rows, _ = tbl_rows_get(self.database, 'lesson', [
'teacher', 'student', 'period', 'dow', 'subject', 'recordtype'
])
self.assertListEqual(expected_result, rows)
def test_persist_multi_teacher(self):
self.database = Database('htmlparser',True)
with self.database:
self.assertEquals(tbl_count_get(self.database,'teacher'),1)
_,rowvals = tbl_rows_get(self.database,'teacher',['userdefid'])
self.assertListEqual(rowvals,[['MOIRA']])
def test_persist_lesson(self):
_dm = _cdict(['schedule_num','day_num','period_num','student_num'],[1,2,2,0])
datamembers = _initdatamembers('lesson',**_dm)
_enrich('QUAD CAFE',datamembers)
lesson = _lesson_create(datamembers,self.database,self.of)
with self.database:
lesson.persist()
self.database = Database('htmlparser',True)
with self.database:
colnames,rowvals = tbl_rows_get(self.database,'lesson',datamembers.keys())
rowvals = [str(val) for val in rowvals[0]]
rowvals.sort()
exp_res = datamembers.values()
exp_res.sort()
self.assertListEqual(rowvals,exp_res)
def test_add_dow(self):
expected_result = [[u'Monday', u'MO', u'1'], [u'Tuesday', u'TU', u'2'],
[u'Thursday', u'TH', u'3'],
[u'Wednesday', u'WE',
u'4'], [u'Friday', u'FR', u'5'],
[u'XX', u'Foobarday', u'6']]
objtype = 'dow'
datamembers = {'name': 'XX', 'code': 'Foobarday'}
args = dict(database=self.database,
refdatabase=self.database,
prepmap=self.prepmap,
of=self.of,
enums=self.enums,
objtype=objtype,
datamembers=datamembers)
ssviewer_utils.dataset_add(**args)
with self.database:
_, rows, _ = tbl_rows_get(self.database, "dow",
['name', 'code', 'enum'])
self.assertEqual(rows, expected_result)
def test_persist_multi_student(self):
self.database = Database('htmlparser',True)
with self.database:
self.assertEquals(tbl_count_get(self.database,'student'),1)
_,rowvals = tbl_rows_get(self.database,'student',['userdefid'])
self.assertListEqual(rowvals,[['NATHANIEL']])
def test_add_period_object(self):
expected_result = [[u'330-400']]
objtype = 'period'
datamembers = {'name': '330-400', 'code': '330'}
args = dict(database=self.database,
refdatabase=self.database,
prepmap=self.prepmap,
of=self.of,
enums=self.enums,
objtype=objtype,
datamembers=datamembers)
newobj = ssviewer_utils.dataset_add(**args)
with self.database:
_, rows, _ = tbl_rows_get(self.database, "period", ['name'],
[["name", "=", "\"330-400\""]])
self.assertEqual(rows, expected_result)
expected_result = {
'code': '330',
'name': '330-400',
'enum': 11,
'objtype': 'period',
'userobjid': '330-400'
}
newobj.dm.pop('id')
#print newobj.dm,expected_result
self.assertEqual(newobj.dm, expected_result)
def test_lesson(self):
records = [[7, 'Tuesday', 'STEM', 'Thea', u'Simon A', '1-on-1'],
[6, 'Wednesday', 'Humanities', 'Jess', 'Liam', '1-on-1']]
expected_results = [[
u'Liam', u'WE', u'1210-1250', u'Jess', u'Humanities',
u'Jess.Humanities.Wednesday.1210-1250'
],
[
u'Simon A', u'TU', u'1250-130', u'Thea',
u'STEM', u'Thea.STEM.Tuesday.1250-130'
]]
expected_results.sort()
dbinsert_direct(self.database, records, 'lesson', 'test', [
'period', 'dow', 'subject', 'adult', 'student', 'recordtype',
'numstudents'
])
with self.database:
_, rows, _ = tbl_rows_get(
self.database, 'lesson',
['student', 'dow', 'period', 'teacher', 'subject', 'session'])
rows.sort()
self.assertListEqual(expected_results, rows)
def test_update_add(self):
# check that a record can be updated after it has been added
expected_results = [['status', 'substatus', 'recordtype', 'period', 'dow', 'source', 'session', 'adult', 'student', 'id', 'objtype', 'prep', 'userobjid', 'subject'],
[u'master', u'complete', u'academic', u'1030-1110', u'MO', u'dbinsert', u'Dylan.Game Period.Monday.1030-1110', u'Dylan', u'Clayton', 'lesson', 5, u'4.1.2.37.37', u'Game Period'],
['master', 'complete', 'academic', '1030-1110', u'TU', 'manual', 'Stan.Math.Tuesday.830-910', 'Stan', 'Nathaniel', 'lesson', 5, '1.2.1.2.4', 'Math']]
datamembers = {'student':'Nathaniel',
'teacher':'Stan',
'subject':'Math',
'period':'830-910',
'recordtype':'academic',
'dow':'Tuesday'}
args = dict(database=self.database,refdatabase=self.database,prepmap=self.prepmap,of=self.of,enums=self.enums,
datamembers=datamembers,keepversion=True)
obj = ssviewer_utils.dataset_add(**args)
obj.keepversion=True
obj.customtimestamp = "%y%m%d_%H%M%S"
newid = obj.update(self.of,'period','1030-1110',self.dbname)
grid,colnames = ssviewer_utils.dataset_list(self.of,self.enums,columns=['status', 'substatus', 'recordtype', 'period', 'dow', 'source', 'session', 'adult', 'student', 'objtype', 'prep', 'userobjid', 'subject'])
self.assertListEqual(grid,expected_results)
# tests whats in the database
expected_results = [[u'Dylan', u'Clayton', u'1030-1110', u'MO', u'Game Period', u'academic', u'current', u'master', u'complete', u'dbinsert'],
[u'Stan', u'Nathaniel', u'830-910', u'TU', u'Math', u'academic', u'version', u'master', u'complete', u'manual'],
[u'Stan', u'Nathaniel', u'1030-1110', u'TU', u'Math', u'academic', u'current', u'master', u'complete', u'manual']]
with self.database:
_,rows,_ = tbl_rows_get(self.database,'lesson',['teacher','student','period','dow','subject','recordtype','__version','status','substatus','source'])
self.assertListEqual(rows,expected_results)
def test_2updates(self):
expected_results = [[123, u'version'], [678, u'version'], [91011, u'current']]
with self.database:
self.dbg.persist()
origid = self.dbg.id
self.dbg.update('col1',678)
self.dbg.update('col1',91011)
_,tbl_rows,_ = tbl_rows_get(self.database,'dbtbltest',['col1','__version'])
# check the value has been updated
self.assertEqual(self.dbg.col1,91011)
#check the id should have been updated
newid = self.dbg.id
self.assertNotEqual(newid,origid)
# check the db representation
self.assertListEqual(expected_results,tbl_rows)
# check the internal dict representation
self.assertEquals(self.dbg.dm,{'col1':91011})
def test_update_adult(self):
expected_results = [
[
u'master', u'complete', u'academic', u'830-910', u'WE',
u'dbinsert', u'[Dylan,Francisco].Movement.Wednesday.830-910',
u'[Dylan,Francisco]', u'Nathaniel', 5, u'1.4.1.None.8',
u'Movement'
],
[
u'master', u'complete', u'academic', u'830-910', u'WE',
u'dbinsert', u'[Dylan,Francisco].Movement.Wednesday.830-910',
u'Amelia', u'Nathaniel', 5, u'1.4.1.None.8', u'Movement'
]
]
obj = self.of.query_advanced("lesson", [('period', '830-910'),
('dow', 'WE')])
obj[0].update(self.of, 'teacher', 'Amelia')
with self.database:
_, rows, _ = tbl_rows_get(
self.database,
"lesson",
fields=[
'status', 'substatus', 'recordtype', 'period', 'dow',
'source', 'session', 'teacher', 'student', 'prep',
'userobjid', 'subject'
],
whereclause=[["period", "=", "\"830-910\""],
["dow", "=", "\"WE\""]])
self.assertListEqual(rows, expected_results)
def test_schdloadpsist_lessons(self):
self.database = Database('htmlparser',True)
exp_results = [['8:30-9:10','Monday','MOVEMENT','None','other'],
['8:30-9:10','Tuesday','MOVEMENT','None','other'],
['8:30-9:10','Wednesday','CHESS','RAHUL','break'],
['8:30-9:10','Thursday','CORE','None','other'],
['8:30-9:10','Friday','STEM','None','edu'],
['9:11-9:51','Monday','YOGA','None','other'],
['9:11-9:51','Tuesday','ART','None','edu'],
['9:11-9:51','Wednesday','READING PERIOD','NATHANIEL','other'],
['9:11-9:51','Thursday','SCIENCE','None','edu'],
['9:11-9:51','Friday','MOVEMENT','None','other'],
['9:52-10:32','Monday','ELA','None','edu'],
['9:52-10:32','Tuesday','MATH','None','edu'],
['9:52-10:32','Wednesday','MUSIC','None','other'],
['9:52-10:32','Thursday','CHESS','RAHUL','break'],
['9:52-10:32','Friday','HUMANITIES','None','edu'],
['10:33-11:13','Monday','None','DYLAN','nwp'],
['10:33-11:13','Tuesday','MATH','MOIRA','wp'],
['10:33-11:13','Wednesday','MATH','None','edu'],
['10:33-11:13','Thursday','None','DYLAN','nwp'],
['10:33-11:13','Friday','OT','None','edu'],
['11:13-11:45','Monday','LUNCH COMPUTER TIME','None','break'],
['11:13-11:45','Tuesday','LUNCH COMPUTER TIME','None','break'],
['11:13-11:45','Wednesday','LUNCH COMPUTER TIME','None','break'],
['11:13-11:45','Thursday','LUNCH COMPUTER TIME','None','break'],
['11:13-11:45','Friday','LUNCH COMPUTER TIME','None','break'],
['11:45-12:25','Monday','ANIMAL RESEARCH','ISAAC','wp'],
['11:45-12:25','Tuesday','SOCIAL STUDIES','None','edu'],
['11:45-12:25','Wednesday','MATH','DYLAN','wp'],
['11:45-12:25','Thursday','None','EMILY','psych'],
['11:45-12:25','Friday','None','None','None'],
['12:26-1:06','Monday','YOGA','DYLAN','other'],
['12:26-1:06','Tuesday','None','DYLAN','nwp'],
['12:26-1:06','Wednesday','None','RACHEL','nwp'],
['12:26-1:06','Thursday','SOCIAL STUDIES','None','edu'],
['12:26-1:06','Friday','None','None','None'],
['1:07-1:47','Monday','SCIENCE','None','edu'],
['1:07-1:47','Tuesday','SOCIAL STUDIES','DYLAN','wp'],
['1:07-1:47','Wednesday','MOVEMENT','None','other'],
['1:07-1:47','Thursday','SOCIAL STUDIES','RICKY','wp'],
['1:07-1:47','Friday','None','None','None'],
['1:48-2:28','Monday','SCIENCE','KAYLA','wp'],
['1:48-2:28','Tuesday','CORE','EMILY','other'],
['1:48-2:28','Wednesday','ELA','None','edu'],
['1:48-2:28','Thursday','CHESS','RAHUL','break'],
['1:48-2:28','Friday','None','None','None'],
['2:30-3:00','Monday','END COMPUTER TIME','None','break'],
['2:30-3:00','Tuesday','END COMPUTER TIME','None','break'],
['2:30-3:00','Wednesday','END COMPUTER TIME','None','break'],
['2:30-3:00','Thursday','END COMPUTER TIME','None','break'],
['2:30-3:00','Friday','None','None','None']]
with self.database:
self.assertEquals(tbl_count_get(self.database,'lesson'),50)
_,rowvals = tbl_rows_get(self.database,'lesson',['period','dow','subject',
'teacher','lessontype'])
self.assertListEqual(rowvals,exp_results)
def test_schdloadpsist_teacher(self):
self.database = Database('htmlparser',True)
with self.database:
self.assertEquals(tbl_count_get(self.database,'teacher'),2)
_,rowvals = tbl_rows_get(self.database,'teacher',['userdefid'])
rowvals.sort()
self.assertListEqual(rowvals,[['NATHANIEL'],['RAHUL']])
def test_schdloadpsist_subject(self):
self.database = Database('htmlparser',True)
with self.database:
self.assertEquals(tbl_count_get(self.database,'subject'),8)
_,rowvals = tbl_rows_get(self.database,'subject',['userdefid'])
rowvals.sort()
self.assertListEqual(rowvals,[['ART'],['CHESS'],['CORE'],['MOVEMENT'],['READING PERIOD'],['SCIENCE'],['STEM'],['YOGA']])
def test_persist_multi_period(self):
self.database = Database('htmlparser',True)
with self.database:
self.assertEquals(tbl_count_get(self.database,'period'),3)
_,rowvals = tbl_rows_get(self.database,'period',['userdefid'])
rowvals.sort()
self.assertListEqual(rowvals,[['10:33-11:13'],['1:07-1:47'],['2:30-3:00']])
def test_persist_multi_subject(self):
self.database = Database('htmlparser',True)
with self.database:
self.assertEquals(tbl_count_get(self.database,'subject'),2)
_,rowvals = tbl_rows_get(self.database,'subject',['userdefid'])
rowvals.sort()
self.assertListEqual(rowvals,[['HUMANITIES'],['MATH']])
def test_persist_multi_dow(self):
self.database = Database('htmlparser',True)
with self.database:
self.assertEquals(tbl_count_get(self.database,'dow'),2)
_,rowvals = tbl_rows_get(self.database,'dow',['userdefid'])
rowvals.sort()
self.assertListEqual(rowvals,[['Friday'],['Wednesday']])
def _loadprepmapper(database):
cols = ['name','prep']
with database:
_,rows,_ = tbl_rows_get(database,'student',cols)
d = dict((row[0],row[1]) for row in rows)
return d
def _loadprepmapper(database):
cols = ['name', 'prep']
with database:
_, rows, _ = tbl_rows_get(database, 'student', cols)
d = dict((row[0], row[1]) for row in rows)
return d
def test_dbobject_db_obj_insert(self):
# tests that string values are wrapped in quotes
with self.database:
#with self.assertRaises(Exception):
self.dbg.persist()
col_name,tbl_rows,_ = tbl_rows_get(self.database,'dbtbltest',['col1'])
self.assertEquals([["1.1.1"]],tbl_rows)
def test_schdloadpsiststudent(self):
self.database = Database('htmlparser',True)
exp_results = [['NATHANIEL']]
with self.database:
self.assertEquals(tbl_count_get(self.database,'student'),1)
_,rowvals = tbl_rows_get(self.database,'student',['userdefid'])
self.assertListEqual(rowvals,exp_results)
def test_schdloadpsistobjtype(self):
self.database = Database('htmlparser',True)
exp_results = ['period','student','teacher','dow','lessontype','subject','lesson']
with self.database:
self.assertEquals(tbl_count_get(self.database,'objtype'),7)
_,rowvals = tbl_rows_get(self.database,'objtype',['userdefid'])
self.assertListEqual(rowvals,exp_results)
def test_(self):
dbinsert(self.database, 'session2', self.rows, self.cols)
with self.database:
_, rows, _ = tbl_rows_get(self.database, 'session2', self.cols)
print rows
def test_persist(self):
with self.database:
self.dbg.persist()
self.database = Database(test_db.name,True)
with self.database:
col_name,tbl_rows,_ = tbl_rows_get(self.database,'dbtbltest',['col1'])
self.assertEquals([["abc"]],tbl_rows)
def test_(self):
dbinsert(self.database,'session2',self.rows,self.cols)
with self.database:
_,rows,_ = tbl_rows_get(self.database,'session2',self.cols)
print rows
def test_(self):
tbl_move(self.database1,self.database2,'workout',True)
expected_results = [[250772, u'cycling'], [260772, u'rowing']]
with self.database2:
_,rows,_ = tbl_rows_get(self.database2,'workout')
self.assertListEqual(rows,expected_results)
def test_persist(self):
with self.database:
self.foobar.persist()
self.database = Database('foobar',True)
with self.database:
col_name,tbl_rows,_ = tbl_rows_get(self.database,'DBLesson',['student','teacher'])
self.assertEquals([['Booker','Amelia']],tbl_rows)
def test_dbwrite(self):
expected_result = [['830-910', u'Nathaniel', 'STAN.BK.DRA.MO', u'MO', '2']]
cols = ['period','student','session','dow','saveversion']
with self.database:
colndefn,rows,exec_str = tbl_rows_get(self.database,'lesson',cols,[['saveversion',"=",'2']])
self.assertListEqual(expected_result,rows)
def test_dbwrite(self):
expected_result = [['830-910', u'Nathaniel', 'STAN.BK.DRA.MO', u'MO', '2']]
cols = ['period','student','session','dow','saveversion']
with self.database:
colndefn,rows,exec_str = tbl_rows_get(self.database,'lesson',cols,[['saveversion',"=",'2']])
self.assertListEqual(expected_result,rows)
def test_1file_no_limits(self):
self.tcxparser.persist(self.test_file_name)
database = Database('foo',True)
with database:
_,rows,_ = tbl_rows_get(database,'foo')
self.assertListEqual(self.expected_results,rows)
def test_persist_customtimestamp(self):
self.foobar.customtimestamp = "%y%m%d_%H%M%S"
with self.database:
self.foobar.persist()
self.database = Database('foobar',True)
with self.database:
col_name,tbl_rows,_ = tbl_rows_get(self.database,'DBLesson',['__timestamp'])
self.assertTrue(13,len(tbl_rows[0][0]))
def test_1file_no_limits_fail_to_write_to_db(self):
self.tcxparser.persist(self.test_file_name,
column_names =["id","foobar","watts","hr","filename"])
database = Database('foo',True)
with database:
_,rows,_ = tbl_rows_get(database,'foo')
self.assertListEqual([],rows)
def test_dbobject_db_str_insert(self):
# tests that string values are wrapped in quotes
with self.database:
#with self.assertRaises(S3OperationalError):
self.dbg.persist()
self.database = Database(test_db.name,True)
with self.database:
col_name,tbl_rows,_ = tbl_rows_get(self.database,'dbtbltest',['col1'])
self.assertEquals([["foobar"]],tbl_rows)
def __init__(self,dbname,tblname,fldname,**kwargs):
database = Database(dbname)
with database:
rows = tbl_rows_get(database,tblname,
[fldname])
# rows is a tuple; list is element 2
kwargs['set'] = [row[0] for row in rows[1]]
super(DBSetMember,self).__init__(**kwargs)
self.validations.append(_SetMemberVdt(**kwargs))
def __init__(self,dbname,tblname,fldname,**kwargs):
database = Database(dbname)
with database:
rows = tbl_rows_get(database,tblname,
[fldname])
# rows is a tuple; list is element 2
kwargs['set'] = [row[0] for row in rows[1]]
super(DBSetMember,self).__init__(**kwargs)
self.validations.append(_SetMemberVdt(**kwargs))
def test_dbwrite(self):
expected_result = [[u'830-910', u'Nathaniel', u'AMEL.AC.ELA.MO', u'MO', u'4'],
[u'910-950', u'Nathaniel', u'PARC.AC.ENG.MO', u'MO', u'4']]
cols = ['period','student','session','dow','saveversion']
with self.database:
colndefn,rows,exec_str = tbl_rows_get(self.database,'lesson',cols,[['saveversion','=','4']])
self.assertListEqual(expected_result,rows)
def test_schdloadpsist_lessons(self):
self.database = Database('htmlparser',True)
exp_results = [['8:30-9:10','Monday','MOVEMENT','None','other'], ['8:30-9:10','Tuesday','MOVEMENT','None','other'],
['8:30-9:10','Wednesday','CHESS','RAHUL','break'],['8:30-9:10','Thursday','CORE','None','other'],
['8:30-9:10','Friday','STEM','None','edu']]
with self.database:
self.assertEquals(tbl_count_get(self.database,'lesson'),5)
_,rowvals = tbl_rows_get(self.database,'lesson',['period','dow','subject',
'teacher','lessontype'])
self.assertListEqual(rowvals,exp_results)
def test_update_1field(self):
expected_results = [[u'830', u'AM.AC.SC', u'Booker', u'Amelia', u'version'],
[u'830', u'AM.AC.SC', u'Booker', u'Aaron', u'current']]
self.foobar.customtimestamp = "%y%m%d_%H%M%S"
with self.database:
self.foobar.persist()
self.foobar.update('teacher',"\"Aaron\"")
self.database = Database('foobar',True)
with self.database:
col_name,tbl_rows,_ = tbl_rows_get(self.database,'DBLesson',['period','session','student','teacher','__version'] )
self.assertListEqual(tbl_rows,expected_results)
def test_dbobject_assert_id(self):
from datetime import datetime
with self.database:
self.dbg.persist()
self.database = Database(test_db.name,True)
with self.database:
col_name,tbl_rows,_ = tbl_rows_get(self.database,
'dbtbltest',
['__timestamp','__id'])
dt = datetime.strptime(tbl_rows[0][0],"%H:%M:%S")
self.assertAlmostEqual(datetime.now().min,dt.min)
self.assertAlmostEqual(datetime.now().hour,dt.hour)
self.assertAlmostEqual(datetime.now().second,dt.second)
def test_tbl_rows_insert(self):
database = Database(test_db.name)
with database:
tbl_create(database,test_db.tbl_name,test_db.col_defn)
tbl_rows_insert(database,test_db.tbl_name,test_db.col_name,
test_db.tbl_rows)
database = Database(test_db.name,True)
with database:
col_name,tbl_rows = tbl_rows_get(database,test_db.tbl_name)
self.assertListEqual(col_name,test_db.col_name)
self.assertListEqual(tbl_rows,test_db.tbl_rows)
def test_schdloadpsist_teacher(self):
exp_res = ['DYLAN','EMILY','ISAAC','KAYLA','MELISSA','MOIRA','NATHANIEL','RACHEL','RAHUL', \
'RICKY']
self.database = Database('htmlparser',True)
with self.database:
_,rowvals = tbl_rows_get(self.database,'teacher',['userdefid'])
rowvals.sort()
exp_res.sort()
_exp_res = [[unicode(e,'utf-8')] for e in exp_res]
self.assertListEqual(rowvals,_exp_res)
def test_period_db(self):
expected_results = [[u'830-910', u'830', u'1'],
[u'910-950', u'910', u'2'],
[u'330-410', u'330', u'3']]
ssrest.restquery(self.url + "add/period",
name='330-410',code='330')
db = Database(self.dbname)
with db:
_,rows,_ = tbl_rows_get(db,'period',['name','code','enum'])
self.assertListEqual(expected_results,rows)
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_(self):
start = "10:01"
end = "20:02"
new_file_name = "foo"
ride_title = "foo_title"
workout_type = "z2"
row = _quotestrs(
[[start, end, new_file_name, ride_title, workout_type]])
self.dtr_tcx._write_to_db(row, self.dname, self.tname, self.cdefns,
self.cnames)
expected_results = [[u'10:01', u'20:02', u'foo', u'foo_title', u'z2']]
database = Database(self.dname, True)
with database:
_, rows, _ = tbl_rows_get(database, self.tname)
self.assertListEqual(expected_results, rows)
def get_limits_from_db(self, tablename):
database = Database(self.databasename, testexists=True)
with database:
_, rows, _ = tbl_rows_get(database, tablename)
self.limits = {}
for _row in rows:
start_hour = 0
end_hour = 0
new_file_name = _row[2]
self.limits[new_file_name] = {}
self.limits[new_file_name]['start'] = self.time_to_seconds(_row[0])
self.limits[new_file_name]['end'] = self.time_to_seconds(_row[1])
log.log(PRIORITY.SUCCESS,
msg="limits retreived from database [" + self.databasename +
"[ for files [" + ",".join(self.limits.keys()) + "]")
return self.limits
def test_add_period_db(self):
expected_result = [[u'330-400']]
objtype = 'period'
datamembers = {'name': '330-400', 'code': '330'}
args = dict(database=self.database,
refdatabase=self.database,
prepmap=self.prepmap,
of=self.of,
enums=self.enums,
objtype=objtype,
datamembers=datamembers)
ssviewer_utils.dataset_add(**args)
with self.database:
_, rows, _ = tbl_rows_get(self.database, "period", ['name'],
[["name", "=", "\"330-400\""]])
self.assertEqual(rows, expected_result)
def test_add_adult(self):
expected_result = [[u'Jon', u'JB', u'39']]
objtype = 'adult'
datamembers = {'name': 'Jon', 'code': 'JB', 'prep': 5}
args = dict(database=self.database,
refdatabase=self.database,
prepmap=self.prepmap,
of=self.of,
enums=self.enums,
objtype=objtype,
datamembers=datamembers)
ssviewer_utils.dataset_add(**args)
with self.database:
_, rows, _ = tbl_rows_get(self.database, "adult",
['name', 'code', 'enum'],
[["name", "=", "\"Jon\""]])
self.assertEqual(rows, expected_result)
def test_add_subject(self):
expected_result = [[u'Cycling', u'CYCL', u'38']]
objtype = 'subject'
datamembers = {'name': 'Cycling', 'code': 'CYCL'}
args = dict(database=self.database,
refdatabase=self.database,
prepmap=self.prepmap,
of=self.of,
enums=self.enums,
objtype=objtype,
datamembers=datamembers)
obj = ssviewer_utils.dataset_add(**args)
with self.database:
_, rows, _ = tbl_rows_get(self.database, "subject",
['name', 'code', 'enum'],
[["name", "=", "\"Cycling\""]])
self.assertEqual(rows, expected_result)
def test_(self):
self.dtr_tcx.load_page(self.baseurl)
self.dtr_tcx.login(self.xpaths, self.uname, self.pword)
self.xpaths[
'rideListName'] = "//div[contains(@class,'ride-list-name')]"
rides = self.dtr_tcx.get_rides(1)
self.xpaths['downloadRide'] = "//a[contains(@class,'downloadRide')]"
self.xpaths['rideListDate'] = "//p[contains(@class,'gray-light')]/span"
self.xpaths['rideTitle'] = "//h1[contains(@class,'mb0')]/a"
self.xpaths['notes'] = "//textarea[contains(@class,'form-control')]"
self.dtr_tcx.download_rides(rides, self.xpaths)
database = Database(self.dname, True)
with database:
_, rows, _ = tbl_rows_get(database, self.tname)
self.assertTrue(len(rows), 1)
self.assertTrue(len(rows[0]), 4)
self.xpaths['rideListDate'] = "//p[contains(@class,'gray-light')]/span"
self.xpaths['rideTitle'] = "//h1[contains(@class,'mb0')]/a"
# get the file name that would have been downloaded
# check it has been downloaded and then delete it
self.dtr_tcx.mydriver.get(rides[0])
ride_file_name = self.dtr_tcx._get_ride_file_name(
rides[0], self.xpaths)
self.assertTrue(os_file_exists(DOWNLOAD_DIR + "\\" + ride_file_name))
os.remove(DOWNLOAD_DIR + "\\" + ride_file_name)
def test_update_add(self):
# check that a record can be updated after it has been added
expected_results = [[
'status', 'substatus', 'recordtype', 'period', 'dow', 'source',
'session', 'adult', 'student', 'id', 'objtype', 'prep',
'userobjid', 'subject'
],
[
u'master', u'complete', u'academic',
u'1030-1110', u'MO', u'dbinsert',
u'Dylan.Game Period.Monday.1030-1110',
u'Dylan', u'Clayton', 'lesson', 5,
u'4.1.2.37.37', u'Game Period'
],
[
'master', 'complete', 'academic', '1030-1110',
u'TU', 'manual', 'Stan.Math.Tuesday.830-910',
'Stan', 'Nathaniel', 'lesson', 5, '1.2.1.2.4',
'Math'
]]
datamembers = {
'student': 'Nathaniel',
'teacher': 'Stan',
'subject': 'Math',
'period': '830-910',
'recordtype': 'academic',
'dow': 'Tuesday'
}
args = dict(database=self.database,
refdatabase=self.database,
prepmap=self.prepmap,
of=self.of,
enums=self.enums,
datamembers=datamembers,
keepversion=True)
obj = ssviewer_utils.dataset_add(**args)
obj.keepversion = True
obj.customtimestamp = "%y%m%d_%H%M%S"
newid = obj.update(self.of, 'period', '1030-1110', self.dbname)
grid, colnames = ssviewer_utils.dataset_list(
self.of,
self.enums,
columns=[
'status', 'substatus', 'recordtype', 'period', 'dow', 'source',
'session', 'adult', 'student', 'objtype', 'prep', 'userobjid',
'subject'
])
self.assertListEqual(grid, expected_results)
# tests whats in the database
expected_results = [[
u'Dylan', u'Clayton', u'1030-1110', u'MO', u'Game Period',
u'academic', u'current', u'master', u'complete', u'dbinsert'
],
[
u'Stan', u'Nathaniel', u'830-910', u'TU',
u'Math', u'academic', u'version', u'master',
u'complete', u'manual'
],
[
u'Stan', u'Nathaniel', u'1030-1110', u'TU',
u'Math', u'academic', u'current', u'master',
u'complete', u'manual'
]]
with self.database:
_, rows, _ = tbl_rows_get(self.database, 'lesson', [
'teacher', 'student', 'period', 'dow', 'subject', 'recordtype',
'__version', 'status', 'substatus', 'source'
])
self.assertListEqual(rows, expected_results)
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 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 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])
