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])  
Beispiel #3
0
 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)
Beispiel #10
0
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)
Beispiel #14
0
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
Beispiel #15
0
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)