def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.full_clean()
self.c.save()
self.season = Season()
self.season.club = self.c
self.season.year = 2011
self.season.save()
self.e = Event()
self.e.name = "test event"
self.e.date = datetime.date.today()
self.e.season = self.season
self.e.club = self.c
self.e.save()
self.sess = Session()
self.sess.name = "AM"
self.sess.event = self.e
self.sess.club = self.c
self.sess.save()
self.classes = ["A", "B", "C", "D", "E", "F", "G", "H"]
self.paxes = [1.0, .98, .96, .94, .92, .90, .88, .86]
for klass, pax in zip(self.classes, self.paxes):
self.race_class = RaceClass()
self.race_class.name = klass
self.race_class.pax = pax
self.race_class.club = self.c
self.race_class.save()
for i in range(0, 10):
self.r = Registration()
self.r.number = i
self.r.race_class = self.race_class
self.r._anon_f_name = "%s%d"%(self.race_class.name, i)
self.r.pax_class = None
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make two regs with empty runs for each class
if self.race_class.name!="H" and i < 8: #one race class with no results
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j #91.0 is lowest raw time (*0.88 for index)
run.result = self.result
run.club = self.c
run.save()
def test_pax_class_one_result(self):
self.race_class = RaceClass()
self.race_class.name = "Pro"
self.race_class.abrv ="X"
self.race_class.pax = 1.0
self.race_class.pax_class=True
self.race_class.club = self.c
self.race_class.save()
for i, pax_name in zip(range(0, 7), self.classes):
rc = RaceClass.objects.filter(name=pax_name).get()
self.r = Registration()
self.r.number = 10*(1+i)
self.r.race_class = rc
self.r._anon_f_name = "%s_%d"%(self.race_class.name, i)
self.r.pax_class = self.race_class
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make regs with runs for each class
if rc.name!="H":
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
race_classes = self.e.calc_results()
self.assertEqual([u"A", u"B", u"C", u"D", u"E", u"F", u"G", u"Pro"], [rc.name for rc in race_classes])
#make sure the results come back sorted
for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results
self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))
if rc.name != "Pro":
self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
self.assertEqual(8, len(regs))
else:
self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs])
self.assertEqual(7, len(regs))
regs = self.e.get_results()
self.assertEqual(regs[0].total_index_time, (91.0)*.88)
self.assertEqual(index_point_ladder[:63], [reg.index_points for reg in regs])
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.save()
self.season = Season()
self.season.club = self.c
self.season.year = 2011
self.season.save()
self.race_class = RaceClass()
self.race_class.name = "CSP"
self.race_class.pax = .875
self.race_class.club = self.c
self.race_class.save()
self.e = Event()
self.e.name = "test event"
self.e.date = datetime.date.today()
self.e.season = self.season
self.e.club = self.c
self.e.save()
self.sess = Session()
self.sess.name = "AM"
self.sess.event = self.e
self.sess.club = self.c
self.sess.save()
self.r = Registration()
self.r.number = 11
self.r.race_class = self.race_class
self.r.pax_class = None
self.r.event = self.e
self.r.club = self.c
self.r.save()
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
def test_no_index_classes_two_result(self):
self.sess = Session()
self.sess.name = "PM"
self.sess.event = self.e
self.sess.club = self.c
self.sess.save()
for klass, pax in zip(self.classes, self.paxes):
self.race_class = RaceClass.objects.filter(name=klass).get()
for i in range(0, 10):
self.r = Registration.objects.filter(_anon_f_name="%s%d"%(self.race_class.name, i)).get()
#make regs with empty runs for each class
if self.race_class.name!="H" and i < 8: #one race class with no results
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
self.r = Registration.objects.filter(_anon_f_name="%s%d"%(self.race_class.name, i)).get()
race_classes = self.e.calc_results()
self.assertEqual(["A", "B", "C", "D", "E", "F", "G"], [rc.name for rc in race_classes])
#make sure the results come back sorted
for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results
self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))
self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
self.assertEqual(8, len(regs))
regs = self.e.get_results()
self.assertEqual(regs[0].total_index_time, 2*(91.0)*.88)
self.assertEqual(index_point_ladder[:56], [reg.index_points for reg in regs])
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.save()
self.season = Season()
self.season.club = self.c
self.season.year = 2011
self.season.save()
self.race_class = RaceClass()
self.race_class.name = "CSP"
self.race_class.pax = 0.875
self.race_class.club = self.c
self.race_class.save()
self.e = Event()
self.e.name = "test event"
self.e.date = datetime.date.today()
self.e.season = self.season
self.e.club = self.c
self.e.save()
self.sess = Session()
self.sess.name = "AM"
self.sess.event = self.e
self.sess.club = self.c
self.sess.save()
self.r = Registration()
self.r.number = 11
self.r.race_class = self.race_class
self.r.pax_class = None
self.r.event = self.e
self.r.club = self.c
self.r.save()
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
def test_no_dibs(self):
reg = Registration()
up = UserProfile.objects.get(user=self.u1)
reg.user_profile = up
reg.number = 15
reg.race_class = self.race_class
reg.pax_class = None
reg.event = self.e4
reg.club = self.c
reg.save()
s = Session()
s.event = self.e4
s.name = "AM"
s.club = self.c
s.save()
result = Result()
result.reg = reg
result.session = s
result.club = self.c
result.save()
for k in range(0, 3):
r = Run()
r.base_time = 10.0
r.calc_time = 10.0
r.index_time = 10.0
r.result = result
r.club = self.c
r.save()
self.c.assign_dibs()
self.assertEqual(len(Dibs.objects.all()), 0)
reg.delete()
s.delete()
class TestResult(unittest.TestCase):
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.save()
self.season = Season()
self.season.club = self.c
self.season.year = 2011
self.season.save()
self.race_class = RaceClass()
self.race_class.name = "CSP"
self.race_class.pax = 0.875
self.race_class.club = self.c
self.race_class.save()
self.e = Event()
self.e.name = "test event"
self.e.date = datetime.date.today()
self.e.season = self.season
self.e.club = self.c
self.e.save()
self.sess = Session()
self.sess.name = "AM"
self.sess.event = self.e
self.sess.club = self.c
self.sess.save()
self.r = Registration()
self.r.number = 11
self.r.race_class = self.race_class
self.r.pax_class = None
self.r.event = self.e
self.r.club = self.c
self.r.save()
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
def tearDown(self):
Club.objects.all().delete()
Season.objects.all().delete()
RaceClass.objects.all().delete()
Event.objects.all().delete()
Session.objects.all().delete()
Registration.objects.all().delete()
Result.objects.all().delete()
Run.objects.all().delete()
def test_best_run1(self):
r1 = Run()
r1.base_time = 10.0
r1.result = self.result
r1.club = self.c
r1.save()
r2 = Run()
r2.base_time = 11.0
r2.result = self.result
r2.club = self.c
r2.save()
r3 = Run()
r3.base_time = 9.0
r3.cones = 1
r3.result = self.result
r3.club = self.c
r3.save()
r4 = Run()
r4.base_time = 10.0
r4.result = self.result
r4.penalty = "DNF"
r4.club = self.c
r4.save()
best_run = self.result.find_best_run()
self.assertEqual(best_run, r1)
def test_best_run2(self):
r1 = Run()
r1.base_time = 10.0
r1.result = self.result
r1.club = self.c
r1.save()
best_run = self.result.find_best_run()
self.assertEqual(best_run, r1)
def test_best_run3(self):
r1 = Run()
r1.base_time = 10.0
r1.result = self.result
r1.club = self.c
r1.save()
r2 = Run()
r2.base_time = 9.0
r2.result = self.result
r2.club = self.c
r2.save()
r3 = Run()
r3.base_time = 10.5
r3.result = self.result
r3.club = self.c
r3.save()
best_run = self.result.find_best_run()
self.assertEqual(best_run, r2)
def test_best_run_no_clean_runs(self):
r1 = Run()
r1.base_time = 10.0
r1.result = self.result
r1.penalty = "DNF"
r1.club = self.c
r1.save()
r2 = Run()
r2.base_time = 0.1
r2.result = self.result
r2.penalty = "O/C"
r2.club = self.c
r2.save()
best_run = self.result.find_best_run()
self.assertEqual(best_run, None)
def setUp(self):
self.today = datetime.date.today()
self.c = Club()
self.c.name = "test"
self.c.events_for_dibs = 2
self.c.save()
self.race_class = RaceClass()
self.race_class.name = "CSP"
self.race_class.pax = .875
self.race_class.club = self.c
self.race_class.save()
self.s = Season()
self.s.year = 2011
self.s.club = self.c
self.s.save()
self.e1 = Event()
self.e1.name = "event1"
self.e1.date = self.today-datetime.timedelta(days=10)
self.e1.season = self.s
self.e1.club = self.c
self.e1.save()
self.e2 = Event()
self.e2.name = "event2"
self.e2.date = self.today-datetime.timedelta(days=8)
self.e2.season = self.s
self.e2.club = self.c
self.e2.save()
self.e3 = Event()
self.e3.name = "event3"
self.e3.date = self.today-datetime.timedelta(days=5)
self.e3.season = self.s
self.e3.club = self.c
self.e3.save()
self.e4 = Event()
self.e4.name = "event4"
self.e4.date = self.today+datetime.timedelta(days=10)
self.e4.season = self.s
self.e4.club = self.c
self.e4.save()
self.events = [self.e1, self.e2, self.e3]
for event in self.events:
s = Session()
s.event = event
s.name = "AM"
s.club = self.c
s.save()
self.u1 = User()
self.u1.username = "******"
self.u1.save()
self.u2 = User()
self.u2.username = "******"
self.u2.save()
self.u3 = User()
self.u3.username = "******"
self.u3.save()
self.users = [self.u1, self.u2, self.u3]
for i, user in enumerate(self.users):
up = user.get_profile()
for j, event in enumerate(self.events):
if j<=i:
r = Registration()
r.number = "%d"%(i+1)
r.race_class = self.race_class
r.pax_class = None
r.event = event
r.user_profile = up
r.club = self.c
r.save()
result = Result()
result.reg = r
result.session = event.sessions.all()[0]
result.club = self.c
result.save()
for k in range(0, 3):
r = Run()
r.base_time = 10.0
r.calc_time = 10.0
r.index_time = 10.0
r.result = result
r.club = self.c
r.save()
def test_calc_times(self):
self.r.save()
sess = Session()
sess.name = "AM"
sess.event = self.e
sess.club = self.c
sess.save()
res = Result()
res.reg = self.r
res.session = sess
res.club = self.c
res.save()
r = Run()
r.base_time = 10.0
r.result = res
r.club = self.c
r.save()
res = Result()
res.reg = self.r
res.session = sess
res.club = self.c
res.save()
r = Run()
r.base_time = 10.0
r.result = res
r.club = self.c
r.save()
self.r.save()
self.r.calc_times()
self.assertEqual(self.r.total_raw_time, 20.0)
self.assertEqual(self.r.total_index_time,
self.r.total_raw_time * self.race_class.pax)
class TestResult(unittest.TestCase):
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.save()
self.season = Season()
self.season.club = self.c
self.season.year = 2011
self.season.save()
self.race_class = RaceClass()
self.race_class.name = "CSP"
self.race_class.pax = .875
self.race_class.club = self.c
self.race_class.save()
self.e = Event()
self.e.name = "test event"
self.e.date = datetime.date.today()
self.e.season = self.season
self.e.club = self.c
self.e.save()
self.sess = Session()
self.sess.name = "AM"
self.sess.event = self.e
self.sess.club = self.c
self.sess.save()
self.r = Registration()
self.r.number = 11
self.r.race_class = self.race_class
self.r.pax_class = None
self.r.event = self.e
self.r.club = self.c
self.r.save()
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
def tearDown(self):
Club.objects.all().delete()
Season.objects.all().delete()
RaceClass.objects.all().delete()
Event.objects.all().delete()
Session.objects.all().delete()
Registration.objects.all().delete()
Result.objects.all().delete()
Run.objects.all().delete()
def test_best_run1(self):
r1 = Run()
r1.base_time = 10.0
r1.result = self.result
r1.club = self.c
r1.save()
r2 = Run()
r2.base_time = 11.0
r2.result = self.result
r2.club = self.c
r2.save()
r3 = Run()
r3.base_time = 9.0
r3.cones = 1
r3.result = self.result
r3.club = self.c
r3.save()
r4 = Run()
r4.base_time = 10.0
r4.result = self.result
r4.penalty = "DNF"
r4.club = self.c
r4.save()
best_run = self.result.find_best_run()
self.assertEqual(best_run, r1)
def test_best_run2(self):
r1 = Run()
r1.base_time = 10.0
r1.result = self.result
r1.club = self.c
r1.save()
best_run = self.result.find_best_run()
self.assertEqual(best_run, r1)
def test_best_run3(self):
r1 = Run()
r1.base_time = 10.0
r1.result = self.result
r1.club = self.c
r1.save()
r2 = Run()
r2.base_time = 9.0
r2.result = self.result
r2.club = self.c
r2.save()
r3 = Run()
r3.base_time = 10.5
r3.result = self.result
r3.club = self.c
r3.save()
best_run = self.result.find_best_run()
self.assertEqual(best_run, r2)
def test_best_run_no_clean_runs(self):
r1 = Run()
r1.base_time = 10.0
r1.result = self.result
r1.penalty = "DNF"
r1.club = self.c
r1.save()
r2 = Run()
r2.base_time = 0.1
r2.result = self.result
r2.penalty = "O/C"
r2.club = self.c
r2.save()
best_run = self.result.find_best_run()
self.assertEqual(best_run, None)
def test_two_bump_class_one_result(self):
self.race_class1 = RaceClass()
self.race_class1.name = "index1"
self.race_class1.pax = 1.0
self.race_class1.club = self.c
self.race_class1.save()
self.race_class2 = RaceClass()
self.race_class2.name = "index2"
self.race_class2.pax = 1.0
self.race_class2.club = self.c
self.race_class2.save()
for i, pax_name in zip(range(0, 7), self.classes):
pax_class = RaceClass.objects.filter(name=pax_name).get()
self.r = Registration()
self.r.number = 10*(1+i)
self.r.race_class = pax_class
self.r._anon_f_name = "%s_%d"%(self.race_class2.name, i)
self.r.bump_class = self.race_class1
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make regs with empty runs for each class
if pax_class.name!="H":
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
self.r = Registration()
self.r.number = 60*(1+i)
self.r.race_class = pax_class
self.r._anon_f_name = "%s_%d"%(self.race_class2.name, i)
self.r.bump_class = self.race_class2
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make regs with empty runs for each class
if pax_class.name!="H":
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
race_classes = self.e.calc_results()
self.assertEqual(set(["A", "B", "C", "D", "E", "F", "G", "index1", "index2"]), set([rc.name for rc in race_classes]))
#make sure the results come back sorted
for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results
self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))
if "index" not in rc.name:
self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
self.assertEqual(8, len(regs))
else:
self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs])
self.assertEqual(7, len(regs))
regs = self.e.get_results()
self.assertEqual(regs[0].total_index_time, (91.0)*.88)
self.assertEqual(index_point_ladder[:70], [reg.index_points for reg in regs])
class TestEventPointsCalc(unittest.TestCase):
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.full_clean()
self.c.save()
self.season = Season()
self.season.club = self.c
self.season.year = 2011
self.season.save()
self.e = Event()
self.e.name = "test event"
self.e.date = datetime.date.today()
self.e.season = self.season
self.e.club = self.c
self.e.save()
self.sess = Session()
self.sess.name = "AM"
self.sess.event = self.e
self.sess.club = self.c
self.sess.save()
self.classes = ["A", "B", "C", "D", "E", "F", "G", "H"]
self.paxes = [1.0, .98, .96, .94, .92, .90, .88, .86]
for klass, pax in zip(self.classes, self.paxes):
self.race_class = RaceClass()
self.race_class.name = klass
self.race_class.pax = pax
self.race_class.club = self.c
self.race_class.save()
for i in range(0, 10):
self.r = Registration()
self.r.number = i
self.r.race_class = self.race_class
self.r._anon_f_name = "%s%d"%(self.race_class.name, i)
self.r.pax_class = None
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make two regs with empty runs for each class
if self.race_class.name!="H" and i < 8: #one race class with no results
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j #91.0 is lowest raw time (*0.88 for index)
run.result = self.result
run.club = self.c
run.save()
def tearDown(self):
clear_db()
def test_no_index_classes_one_result(self):
race_classes = self.e.calc_results()
self.assertEqual(["A", "B", "C", "D", "E", "F", "G"], [rc.name for rc in race_classes])
#make sure the results come back sorted
for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results
self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))
self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
self.assertEqual(8, len(regs))
regs = self.e.get_results()
self.assertEqual(regs[0].total_index_time, (91.0)*.88)
self.assertEqual(index_point_ladder[:56], [reg.index_points for reg in regs])
def test_no_index_classes_two_result(self):
self.sess = Session()
self.sess.name = "PM"
self.sess.event = self.e
self.sess.club = self.c
self.sess.save()
for klass, pax in zip(self.classes, self.paxes):
self.race_class = RaceClass.objects.filter(name=klass).get()
for i in range(0, 10):
self.r = Registration.objects.filter(_anon_f_name="%s%d"%(self.race_class.name, i)).get()
#make regs with empty runs for each class
if self.race_class.name!="H" and i < 8: #one race class with no results
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
self.r = Registration.objects.filter(_anon_f_name="%s%d"%(self.race_class.name, i)).get()
race_classes = self.e.calc_results()
self.assertEqual(["A", "B", "C", "D", "E", "F", "G"], [rc.name for rc in race_classes])
#make sure the results come back sorted
for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results
self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))
self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
self.assertEqual(8, len(regs))
regs = self.e.get_results()
self.assertEqual(regs[0].total_index_time, 2*(91.0)*.88)
self.assertEqual(index_point_ladder[:56], [reg.index_points for reg in regs])
def test_pax_class_one_result(self):
self.race_class = RaceClass()
self.race_class.name = "Pro"
self.race_class.abrv ="X"
self.race_class.pax = 1.0
self.race_class.pax_class=True
self.race_class.club = self.c
self.race_class.save()
for i, pax_name in zip(range(0, 7), self.classes):
rc = RaceClass.objects.filter(name=pax_name).get()
self.r = Registration()
self.r.number = 10*(1+i)
self.r.race_class = rc
self.r._anon_f_name = "%s_%d"%(self.race_class.name, i)
self.r.pax_class = self.race_class
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make regs with runs for each class
if rc.name!="H":
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
race_classes = self.e.calc_results()
self.assertEqual([u"A", u"B", u"C", u"D", u"E", u"F", u"G", u"Pro"], [rc.name for rc in race_classes])
#make sure the results come back sorted
for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results
self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))
if rc.name != "Pro":
self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
self.assertEqual(8, len(regs))
else:
self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs])
self.assertEqual(7, len(regs))
regs = self.e.get_results()
self.assertEqual(regs[0].total_index_time, (91.0)*.88)
self.assertEqual(index_point_ladder[:63], [reg.index_points for reg in regs])
def test_one_bump_class_one_result(self):
self.race_class = RaceClass()
self.race_class.name = "index"
self.race_class.pax = 1.0
self.race_class.club = self.c
self.race_class.save()
for i, pax_name in zip(range(0, 7), self.classes):
rc = RaceClass.objects.filter(name=pax_name).get()
self.r = Registration()
self.r.number = 10*(1+i)
self.r.race_class = rc
self.r._anon_f_name = "%s_%d"%(self.race_class.name, i)
self.r.bump_class = self.race_class
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make regs with empty runs for each class
if rc.name!="H":
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
race_classes = self.e.calc_results()
self.assertEqual(["A", "B", "C", "D", "E", "F", "G", "index"], [rc.name for rc in race_classes])
#make sure the results come back sorted
for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results
self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))
if rc.name != "index":
self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
self.assertEqual(8, len(regs))
else:
self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs])
self.assertEqual(7, len(regs))
regs = self.e.get_results()
self.assertEqual(regs[0].total_index_time, (91.0)*.88)
self.assertEqual(index_point_ladder[:63], [reg.index_points for reg in regs])
def test_two_bump_class_one_result(self):
self.race_class1 = RaceClass()
self.race_class1.name = "index1"
self.race_class1.pax = 1.0
self.race_class1.club = self.c
self.race_class1.save()
self.race_class2 = RaceClass()
self.race_class2.name = "index2"
self.race_class2.pax = 1.0
self.race_class2.club = self.c
self.race_class2.save()
for i, pax_name in zip(range(0, 7), self.classes):
pax_class = RaceClass.objects.filter(name=pax_name).get()
self.r = Registration()
self.r.number = 10*(1+i)
self.r.race_class = pax_class
self.r._anon_f_name = "%s_%d"%(self.race_class2.name, i)
self.r.bump_class = self.race_class1
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make regs with empty runs for each class
if pax_class.name!="H":
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
self.r = Registration()
self.r.number = 60*(1+i)
self.r.race_class = pax_class
self.r._anon_f_name = "%s_%d"%(self.race_class2.name, i)
self.r.bump_class = self.race_class2
self.r.event = self.e
self.r.club = self.c
self.r.save()
#make regs with empty runs for each class
if pax_class.name!="H":
self.result = Result()
self.result.reg = self.r
self.result.session = self.sess
self.result.club = self.c
self.result.save()
for j in range(0, 3):
run = Run()
run.base_time = 100.0-i-j
run.result = self.result
run.club = self.c
run.save()
race_classes = self.e.calc_results()
self.assertEqual(set(["A", "B", "C", "D", "E", "F", "G", "index1", "index2"]), set([rc.name for rc in race_classes]))
#make sure the results come back sorted
for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results
self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time))
if "index" not in rc.name:
self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs])
self.assertEqual(8, len(regs))
else:
self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs])
self.assertEqual(7, len(regs))
regs = self.e.get_results()
self.assertEqual(regs[0].total_index_time, (91.0)*.88)
self.assertEqual(index_point_ladder[:70], [reg.index_points for reg in regs])
def test_calc_times(self):
self.r.save()
sess = Session()
sess.name = "AM"
sess.event = self.e
sess.club = self.c
sess.save()
res = Result()
res.reg = self.r
res.session = sess
res.club = self.c
res.save()
r = Run()
r.base_time = 10.0
r.result = res
r.club = self.c
r.save()
res = Result()
res.reg = self.r
res.session = sess
res.club = self.c
res.save()
r = Run()
r.base_time = 10.0
r.result = res
r.club = self.c
r.save()
self.r.save()
self.r.calc_times()
self.assertEqual(self.r.total_raw_time, 20.0)
self.assertEqual(self.r.total_index_time, self.r.total_raw_time * self.race_class.pax)
def parse_axtime(event, session, results_file):
"""Expects a Session object and a file object with
and iterates through to return either a list of result instances,
or a dictionary containing error messages"""
validate_error = {}
results = []
club = session.club
reader = csv.reader(results_file)
header = reader.next()
header_check = ["First", "Last", "Reg", "Class", "Num", "Vehicle", "Pax_Cls", "Color", "Notes", "Heat"]
if not all([h in header for h in header_check]):
validate_error["results_file"] = "your file was missing some columns"
return validate_error
time_keys = [k for k in header if "Run" in k]
cone_keys = [k for k in header if "Pyl" in k]
pen_keys = [k for k in header if "Pen" in k]
if not all([time_keys, cone_keys, pen_keys]):
validate_error["result_file"] = "your file was missing some run results columns"
return validate_error
keys = header_check + time_keys + cone_keys + pen_keys
for line in reader:
result = Result()
result.session = session
result.club = session.club
data = dict(zip(header, line))
reg_id = data["Notes"]
# find the group class and raceclass:
if data["Class"] == data["Pax_Cls"]:
group = None
else:
try:
group = RaceClass.objects.get(abrv=data["Class"], club=club)
except RaceClass.DoesNotExist:
validate_error["result_file"] = (
"Your Reults for %s %s included a unknown entry, %s in the Class column"
% (data["First"], data["Last"], data["Class"])
)
return validate_error
try:
race_class = RaceClass.objects.get(abrv=data["Pax_Cls"], club=club)
except RaceClass.DoesNotExist:
if not data["Pax_Cls"]:
validate_error["results_file"] = "Your results for %s %s included an blank race class" % (
data["First"],
data["Last"],
)
else:
validate_error["results_file"] = "Your results for %s %s included an unknown race class: %s" % (
data["First"],
data["Last"],
data["Pax_Cls"],
)
return validate_error
car_data = data["Vehicle"].split()
if len(car_data) == 3 and int_check.match(car_data[0]):
data["Vehicle_year"] = car_data[0]
data["Vehicle_make"] = car_data[1]
data["Vehicle_model"] = car_data[2]
elif len(car_data) == 2:
data["Vehicle_year"] = None
data["Vehicle_make"] = car_data[0]
data["Vehicle_model"] = car_data[1]
else:
data["Vehicle_year"] = None
data["Vehicle_make"] = None
data["Vehicle_model"] = data["Vehicle"]
# try REALLY hard to find the registration that maps to this driver
try:
user = User.objects.filter(
username__icontains=data["Mem_Num"],
first_name__icontains=data["First"],
last_name__icontains=data["Last"],
)[0]
except IndexError: # coudn't find one
user = None
if user:
try:
reg = Registration.objects.get(event=event, user_profile__user__username=user.username)
if reg.race_class != race_class:
reg.race_class = race_class
except Registration.DoesNotExist:
reg = Registration()
reg.user_profile = user.get_profile()
reg.number = int(data["Num"])
reg.race_class = race_class
reg.pax_class = group
reg._anon_car = data["Vehicle"]
reg.event = event
reg.club = club
# not sure how this could happen at all...
# except Registration.MultipleObjectsReturned:
# reg = session.query(model.Registration).join(model.Driver).join(model.Event).\
# filter(model.Event.id==c.event.id).filter(model.Driver.user_name==driver.user_name).all()
# for r in reg:
# session.delete(r)
#
# reg = model.Registration()
# reg.driver = driver
# reg.number = int(data['Num'])
# reg.race_class = race_class
# reg.anon_car = unicode(data['Vehicle'])
# reg.event = c.event
else:
# try to find a previous anon_reg
try:
reg = Registration.objects.get(event=event, _anon_f_name=data["First"], _anon_l_name=data["Last"])
except Registration.DoesNotExist:
reg = Registration()
reg.number = int(data["Num"])
reg.race_class = race_class
reg.pax_class = group
reg._anon_f_name = data["First"]
reg._anon_l_name = data["Last"]
reg._anon_car = data["Vehicle"]
reg.event = event
reg.club = club
try:
reg.save()
except:
validate_error["results_file"] = "%s %s has a duplicate class/number: %d %s" % (
reg.first_name,
reg.last_name,
reg.number,
reg.race_class,
)
return validate_error
try:
reg.number = int(data["Num"])
except Exception:
validate_error["results_file"] = "Problem with car number for entry: %s %s" % (
reg.first_name,
reg.last_name,
)
return validate_error
result.reg = reg
result.save()
for r_key, c_key, p_key in zip(time_keys, cone_keys, pen_keys):
run = Run()
run.result = result
run.club = club
try:
if float(data[r_key]) <= 0.0:
continue
except ValueError:
continue
run.base_time = float(data[r_key])
run.cones = int(data[c_key])
if data[p_key].strip():
run.penalty = data[p_key]
run.save()
# note: not sure why this has to be done here
try:
reg.save()
except Exception:
validate_error["results_file"] = "%s %s has a duplicate class/number: %d %s" % (
reg.first_name,
reg.last_name,
reg.number,
reg.race_class,
)
return validate_error
results.append(result)
return results
def parse_axtime(event, session, results_file):
"""Expects a Session object and a file object with
and iterates through to return either a list of result instances,
or a dictionary containing error messages"""
validate_error = {}
results = []
club = session.club
reader = csv.reader(results_file)
header = reader.next()
header_check = [
'First', 'Last', 'Reg', 'Class', 'Num', 'Vehicle', 'Pax_Cls', 'Color',
"Notes", "Heat"
]
if not all([h in header for h in header_check]):
validate_error['results_file'] = "your file was missing some columns"
return validate_error
time_keys = [k for k in header if 'Run' in k]
cone_keys = [k for k in header if 'Pyl' in k]
pen_keys = [k for k in header if 'Pen' in k]
if not all([time_keys, cone_keys, pen_keys]):
validate_error[
'result_file'] = "your file was missing some run results columns"
return validate_error
keys = header_check + time_keys + cone_keys + pen_keys
for line in reader:
result = Result()
result.session = session
result.club = session.club
data = dict(zip(header, line))
reg_id = data['Notes']
#find the group class and raceclass:
if data['Class'] == data['Pax_Cls']:
group = None
else:
try:
group = RaceClass.objects.get(abrv=data['Class'], club=club)
except RaceClass.DoesNotExist:
validate_error[
'result_file'] = 'Your Reults for %s %s included a unknown entry, %s in the Class column' % (
data['First'], data['Last'], data['Class'])
return validate_error
try:
race_class = RaceClass.objects.get(abrv=data['Pax_Cls'], club=club)
except RaceClass.DoesNotExist:
if not data['Pax_Cls']:
validate_error[
'results_file'] = "Your results for %s %s included an blank race class" % (
data['First'], data['Last'])
else:
validate_error[
'results_file'] = "Your results for %s %s included an unknown race class: %s" % (
data['First'], data['Last'], data['Pax_Cls'])
return validate_error
car_data = data['Vehicle'].split()
if len(car_data) == 3 and int_check.match(car_data[0]):
data['Vehicle_year'] = car_data[0]
data['Vehicle_make'] = car_data[1]
data['Vehicle_model'] = car_data[2]
elif len(car_data) == 2:
data['Vehicle_year'] = None
data['Vehicle_make'] = car_data[0]
data['Vehicle_model'] = car_data[1]
else:
data['Vehicle_year'] = None
data['Vehicle_make'] = None
data['Vehicle_model'] = data['Vehicle']
#try REALLY hard to find the registration that maps to this driver
try:
user = User.objects.filter(username__icontains=data['Mem_Num'],
first_name__icontains=data['First'],
last_name__icontains=data['Last'])[0]
except IndexError: #coudn't find one
user = None
if user:
try:
reg = Registration.objects.get(
event=event, user_profile__user__username=user.username)
if reg.race_class != race_class:
reg.race_class = race_class
except Registration.DoesNotExist:
reg = Registration()
reg.user_profile = user.get_profile()
reg.number = int(data['Num'])
reg.race_class = race_class
reg.pax_class = group
reg._anon_car = data['Vehicle']
reg.event = event
reg.club = club
#not sure how this could happen at all...
#except Registration.MultipleObjectsReturned:
# reg = session.query(model.Registration).join(model.Driver).join(model.Event).\
# filter(model.Event.id==c.event.id).filter(model.Driver.user_name==driver.user_name).all()
# for r in reg:
# session.delete(r)
#
# reg = model.Registration()
# reg.driver = driver
# reg.number = int(data['Num'])
# reg.race_class = race_class
# reg.anon_car = unicode(data['Vehicle'])
# reg.event = c.event
else:
#try to find a previous anon_reg
try:
reg = Registration.objects.get(event=event,
_anon_f_name=data['First'],
_anon_l_name=data['Last'])
except Registration.DoesNotExist:
reg = Registration()
reg.number = int(data['Num'])
reg.race_class = race_class
reg.pax_class = group
reg._anon_f_name = data['First']
reg._anon_l_name = data['Last']
reg._anon_car = data['Vehicle']
reg.event = event
reg.club = club
try:
reg.save()
except:
validate_error[
'results_file'] = "%s %s has a duplicate class/number: %d %s" % (
reg.first_name, reg.last_name, reg.number, reg.race_class)
return validate_error
try:
reg.number = int(data['Num'])
except Exception:
validate_error[
'results_file'] = 'Problem with car number for entry: %s %s' % (
reg.first_name, reg.last_name)
return validate_error
result.reg = reg
result.save()
for r_key, c_key, p_key in zip(time_keys, cone_keys, pen_keys):
run = Run()
run.result = result
run.club = club
try:
if float(data[r_key]) <= 0.0:
continue
except ValueError:
continue
run.base_time = float(data[r_key])
run.cones = int(data[c_key])
if data[p_key].strip():
run.penalty = data[p_key]
run.save()
#note: not sure why this has to be done here
try:
reg.save()
except Exception:
validate_error[
'results_file'] = "%s %s has a duplicate class/number: %d %s" % (
reg.first_name, reg.last_name, reg.number, reg.race_class)
return validate_error
results.append(result)
return results
def handle(self, *args, **options):
clear_db()
s = Site.objects.all()[0]
s.domain = "dev.racerslane.com"
s.name = "Racerslane.com"
s.save()
print "Loading users"
reader = csv.DictReader(open('old_data/driver.csv', 'rU'))
for line in reader:
"""user_name","email","verified","activation_code",
"f_name","l_name","address","city","state",
"zip_code","_password"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
u = User()
u.username = line['user_name']
u.email = line['email']
u.password = "******" % line['_password']
u.first_name = line['f_name']
u.last_name = line['l_name']
u.is_active = True
u.save()
up = u.get_profile()
up.address = line['address']
up.city = line['city']
up.state = line['state']
up.zip_code = line['zip_code']
up.save()
db.reset_queries()
#dev to make it so I can login to any account
justin = User.objects.get(username="******")
password = justin.password
#User.objects.all().update(password=password)
print "Loading Cars"
car_map = {}
reader = csv.DictReader(open('old_data/car.csv', 'rb'))
for line in reader:
"""id","nickname","make","model","color","avatar_file_loc",
"avatar_thumb_loc","year","owner_user_name"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
if line['owner_user_name']:
try:
c = Car()
c.provisional = False
c.name = line['nickname']
c.make = line['make']
c.model = line['model']
if line['color']:
c.color = line['color']
c.year = line['year']
c.user_profile = User.objects.get(
username=line['owner_user_name']).get_profile()
s_car_id = (line['owner_user_name'], line['nickname'])
if exists('old_data/avatars/%s_%s_avatar' % s_car_id):
c.avatar.save(
'%s_%s_avatar' % s_car_id,
File(
open('old_data/avatars/%s_%s_avatar' %
s_car_id)))
c.thumb.save(
'%s_%s_thumb' % s_car_id,
File(
open('old_data/avatars/%s_%s_thumb' %
s_car_id)))
c.save()
db.reset_queries()
car_map[line['id']] = c.pk
except:
continue
print "Loading Clubs"
#read in clubs
club_map = {}
for line in csv.DictReader(open('old_data/club.csv', 'rU')):
""""name","web_link","process_payments","points_calc_type",
"membership_cost","renewal_cost","membership_terms","paypal_email",
"index_point_method","address","city","state","zip_code","""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
c = Club()
c.city = line['city']
c.address = line['address']
c.zip_code = line['zip_code']
c.state = line['state']
c.name = line['name']
c.process_payments = line['process_payments']
c.paypal_email = line['paypal_email']
c.membership_terms = line['membership_terms']
c.new_member_cost = line['membership_cost']
c.renew_cost = line['renewal_cost']
c.save()
club_map[line['name']] = c
db.reset_queries()
print "loading coupons"
for line in csv.DictReader(open('old_data/coupon.csv')):
"""coupon_code","club_name","discount_amount","uses_left","expires",
"permanent","driver_user_name","registration_id"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
c = Coupon()
c.code = line['coupon_code']
c.permanent = bool(line['permanent'])
c.club = club_map[line['club_name']]
c.uses_left = line['uses_left']
c.discount_amount = line['discount_amount']
if line['expires']:
c.expires = datetime.datetime.strptime(line['expires'],
'%Y-%m-%d %H:%M:%S')
if line['driver_user_name']:
c.user_prof = User.objects.get(
username=line['driver_user_name']).get_profile()
c.save()
db.reset_queries()
print "loading memberships"
reader = csv.DictReader(open('old_data/membership.csv', 'rb'))
for line in reader:
""""id","club_name","number","start_date","valid_thru_date",
"price","paid","token","payer_id","transaction_id","anon_f_name",
"anon_l_name","driver_user_name"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
m = Membership()
m.num = line['number']
m.start = datetime.datetime.strptime(line['start_date'],
'%Y-%m-%d %H:%M:%S')
m.valid_thru = datetime.datetime.strptime(line['valid_thru_date'],
'%Y-%m-%d %H:%M:%S')
m.paid = bool(line['paid'])
if line['price'] != None:
m.price = float(line['price'])
try:
m.user_prof = User.objects.get(
username=line['driver_user_name']).get_profile()
except User.DoesNotExist:
continue
m.club = club_map[line['club_name']]
m._anon_f_name = line['anon_f_name']
m._anon_l_name = line['anon_l_name']
m.save()
db.reset_queries()
print "loading locations"
location_map = {}
for line in csv.DictReader(open("old_data/location.csv")):
"""id","name","address","lat","lng","club_name"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
club = Club.objects.get(name=line['club_name'])
l = Location()
l.name = line['name']
l.address = line['address']
#l.lat = line['lat']
#l.lon = line['lng']
l.club = club
l.save()
location_map[line['id']] = l
db.reset_queries()
print "loading seasons"
season_map = {}
for line in csv.DictReader(open('old_data/season.csv')):
s = Season()
""""id","year","active","club_name","drop_lowest_events"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
club = Club.objects.get(name=line['club_name'])
s.club = club
s.year = int(line['year'])
s.drop_lowest_events = int(line['drop_lowest_events'])
s.save()
season_map[line['id']] = s
db.reset_queries()
print "loading events"
event_map = {}
for line in csv.DictReader(open('old_data/event.csv', 'rU')):
"""id","name","note","date","registration_close","member_cost",
"non_member_cost","pay_at_event_cost","location_id","club_name",
"season_id","multiplier","count_points"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
e = Event()
e.name = line['name']
e.note = line['note']
e.date = datetime.datetime.strptime(line['date'],
'%Y-%m-%d %H:%M:%S')
e.reg_close = line['registration_close'] + "-05:00"
e.member_price = float(line['member_cost'])
e.non_member_price = float(line['non_member_cost'])
e.non_pre_pay_penalty = float(line['pay_at_event_cost'])
e.season = season_map[line['season_id']]
e.club = e.season.club
e.count_points = int(line['count_points'])
e.multiplier = int(line['multiplier'])
if line['location_id']:
e.location = location_map[line['location_id']]
e.save()
event_map[line['id']] = e
db.reset_queries()
print "loading race_classes"
race_class_map = {}
for line in csv.DictReader(open('old_data/raceclass.csv')):
"""id","pax","name","club_name"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
club = Club.objects.get(name=line['club_name'])
r = RaceClass()
r.name = line['name']
r.abrv = line['name']
r.pax = float(line['pax'])
r.club = club
r.save()
db.reset_queries()
race_class_map[line['id']] = r
index_class = RaceClass()
index_class.name = 'Index'
index_class.bump_class = True
index_class.abrv = "i"
index_class.pax = 1.0
index_class.club = club
index_class.save()
print "loading reg_types"
reg_type_map = {}
for line in csv.DictReader(open('old_data/regtype.csv')):
"""id","name","class_letters","reg_limit","index",
"description","club_name"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
club = Club.objects.get(name=line['club_name'])
r = RaceClass()
r.pax_class = True
r.description = line['description']
r.name = line['name']
r.abrv = line['class_letters']
if line['reg_limit']:
r.user_reg_limit = line['reg_limit']
r.pax = 1.0
r.club = club
r.save()
reg_type_map[line['id']] = r
db.reset_queries()
print "loading registrations"
registration_map = {}
for line in csv.DictReader(open('old_data/registration.csv')):
"""id","number","paid","token","payer_id","transaction_id",
"price","class_points","index_points","index_flag","anon_f_name",
"anon_l_name","anon_car","driver_user_name","event_id","reg_type_id",
"car_id","race_class_id"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
if not line['event_id']:
continue
rc = race_class_map[line['race_class_id']]
r = Registration()
r.paid = bool(line['paid'])
if line['price'] != None:
r.price = float(line['price'])
if line['driver_user_name']:
user = User.objects.get(username=line['driver_user_name'])
r.user_profile = user.get_profile()
r.number = int(line['number'])
r.paid = int(line['paid'])
r.index_points = line['index_points']
r.class_points = line['class_points']
if line['price']:
r.price = float(line['price'])
else:
r.price = 0.00
r.index_points = int(line['index_points'])
r.class_points = int(line['class_points'])
if line['anon_car']:
r._anon_car = line['anon_car'].strip()
if line['anon_l_name']:
r._anon_l_name = line['anon_l_name'].strip()
if line['anon_f_name']:
r._anon_f_name = line['anon_f_name'].strip()
r.race_class = rc
r.event = event_map[line['event_id']]
r.club = r.event.club
try:
if line['reg_type_id']:
r.pax_class = reg_type_map[line['reg_type_id']]
except:
pass
if line['index_flag']:
r.bump_class = index_class
try:
if line['car_id']:
r.car = Car.objects.get(pk=car_map[line['car_id']])
except:
pass
#TODO race_class_id
#TODO remove reg_detail class, and associate reg with UserProfile directly
#TODO registrations can be siblings for joint update
try:
r.save()
except:
r.number += 100
try:
r.save()
except:
continue
registration_map[line['id']] = r.pk
db.reset_queries()
print "loading sessions"
session_map = {}
for line in csv.DictReader(open('old_data/session.csv')):
"""id", "name", "event_id", "course_id"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
try:
event_map[line['event_id']]
except:
continue
s = Session()
s.name = line['name']
s.event = event_map[line['event_id']]
s.club = s.event.club
s.save()
session_map[line['id']] = s
db.reset_queries()
print "loading results"
result_map = {}
for line in csv.DictReader(open('old_data/result.csv')):
"""id","registration_id","event_id","sess_id"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
try:
registration_map[line['registration_id']]
session_map[line['sess_id']]
except:
continue
r = Result()
reg = Registration.objects.get(
pk=registration_map[line['registration_id']])
r.reg = reg
r.session = session_map[line['sess_id']]
r.club = r.session.club
try:
r.save()
except Exception as err:
print registration_map[line['registration_id']].pk
print str(err)
print registration_map[line['registration_id']]
result_map[line['id']] = r.id
db.reset_queries()
print "loading runs"
for line in csv.DictReader(open('old_data/run.csv')):
"""id","base_time","calc_time","index_time","cones",
"penalty","result_id","result_2_id"""
for k, v in line.iteritems():
if v == "NULL":
line[k] = None
if line['base_time'] == None:
continue
try:
r = Run()
r.base_time = float(line['base_time'])
r.cones = int(line['cones'])
if line['penalty']:
r.penalty = line['penalty']
result = Result.objects.get(pk=result_map[line['result_id']])
r.result = result
r.club = r.result.club
r.save()
db.reset_queries()
except KeyError:
continue
print "calculating reg times"
for reg in Registration.objects.select_related(
'results').all().iterator():
reg.calc_times()
#House keeping
nora = Club.objects.get(safe_name='noraascc')
user = User.objects.get(username="******")
nora.group.user_set.add(user)
