def test_with_raceclass(self):
        f = StringIO.StringIO("\n".join(self.data))

        user = User()
        user.first_name = "CHRIS"
        user.last_name = "brubaker"
        user.username = "******"
        user.save()

        self.r = Registration()
        self.r.number = 11
        self.r.race_class = self.rc
        self.r.pax_class = None
        self.r.club = self.c
        self.r.event = self.e

        result = parse_axtime(self.e, self.session, f)[0]
        runs = result.runs.all()

        self.assertEqual(len(runs), 8)
        self.assertEqual(result.best_run, runs[2])

        reg = result.reg
        self.assertEqual(reg.user, user)

        self.assertEqual(reg.number, 73)
Esempio n. 2
0
 def testEventisRegd(self): 
     
     self.e.save()
     
     u = User()
     u.first_name = "Justin" 
     u.last_name = "Gray"
     u.username = "******"
     
     u.save()
     
     rc = RaceClass()
     rc.abrv = "CSP"
     rc.name = "CSP"
     rc.pax = 1
     rc.club = self.c
     rc.save()
             
     self.assertFalse(self.e.is_regd(u))        
     
     r = Registration()
     r.event = self.e
     r.number = 11
     r.race_class = rc
     r.user_profile = u.get_profile()
     r.club = self.c
     r.save()
     
     self.assertTrue(self.e.is_regd(u))
Esempio n. 3
0
 def test_event_reg_limit(self): 
     self.e.save()
     self.sess = Session()
     self.sess.name = "AM"
     self.sess.event = self.e
     self.sess.club = self.c
     self.sess.save()
             
     self.race_class = RaceClass()
     self.race_class.name = "A"
     self.race_class.pax = 1
     self.race_class.club = self.c
     self.race_class.save()        
     
     self.e.reg_limit = 3
     self.e.save()
     
     for i in range(0, 4): 
         try: 
             self.r = Registration()
             self.r.number = i
             self.r.race_class = self.race_class
             self.r._anon_f_name = "random_%d"%(i,)
             self.r.pax_class = None
             self.r.event = self.e
             self.r.club = self.c
             self.r.save()
             
         except ValidationError as err: #don't error untill the limit is reached  
             self.assertEqual(i, 3)
         else: 
             self.assertLess(i, 3)
    def testMaxUserRegLimit(self):
        self.e2 = Event()
        self.e2.name = "test event 2"
        self.e2.date = datetime.date.today()
        self.e2.season = self.season
        self.e2.club = self.c
        self.e2.save()

        self.race_class.user_reg_limit = 1
        self.race_class.save()

        self.r.car = self.car
        self.r.user_profile = self.user_profile
        self.r.event = self.e
        self.r.save()

        self.r2 = Registration()
        self.r2.number = 11
        self.r2.race_class = self.race_class
        self.r2.pax_class = None
        self.r2.event = self.e2
        self.r2.club = self.c
        self.r2.user_profile = self.user_profile

        try:
            self.r2.full_clean()
        except ValidationError as err:
            self.assertEqual(
                "{'__all__': [u'You have reached the registration limit for CSP.']}",
                str(err))
        else:
            self.fail("ValidationError expected")
Esempio n. 5
0
    def save(self, validated_data):
        email = validated_data.get('email')
        new_user = User(
            username=email,
            email=email,
            is_active=False,
        )
        new_user.save()

        # Create new salary instance
        new_salary = Salary(user=new_user)
        new_salary.save()

        # Create new adminprofile instance
        new_adminprofile = AdminProfile(user=new_user)
        new_adminprofile.save()

        # Create new company instance and assign admin_profile to new admin_profile, other fields have placeholder values
        new_company = Company(adminprofile=new_adminprofile)
        new_company.save()

        registration = Registration(
            user=new_user,
            code_type='RV',
            profile_type='AP',
        )
        registration.save()

        email = Email(
            to=email,
            subject='Thank you for registering with RazzPay!',
            content=f'Here is your validation code: {registration.code}')
        email.save(request=self.context['request'])
        return new_user
Esempio n. 6
0
 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()        
Esempio n. 7
0
    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])  
Esempio n. 8
0
def index(request):
    print(request.method)
    if request.method == 'POST':
        name = request.POST.get('fname')
        email = request.POST.get('email')
        m_no = request.POST.get('m_no')
        print(name, email, m_no)
        s = Registration(name=name, email=email, m_no=m_no)
        s.save()
        # sending data to html
    return render(request, 'index.html')
    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.race_class = RaceClass()
        self.race_class.name = "CSP"
        self.race_class.abrv = "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.user = User()
        self.user.first_name = "Justin"
        self.user.last_name = "Gray"
        self.user.username = "******"
        self.user.save()

        self.user2 = User()
        self.user2.first_name = "Eli"
        self.user2.last_name = "Gray"
        self.user2.username = "******"
        self.user2.save()

        self.car = Car()
        self.car.year = 1990
        self.car.make = "Mazda"
        self.car.model = "Miata"
        self.car.user_profile = self.user.get_profile()
        self.car.save()

        self.r = Registration()
        self.r.number = 11
        self.r.race_class = self.race_class
        self.r.pax_class = None
        self.r.club = self.c
        self.r.event = self.e

        self.user_profile = UserProfile.objects.get(user=self.user)
        self.user_profile2 = UserProfile.objects.get(user=self.user2)
Esempio n. 10
0
    def save(self, validated_data):
        # Obtain user info
        email = validated_data.get('email')
        first_name = validated_data.get('first_name')
        last_name = validated_data.get('last_name')
        company = self.context['request'].user.company

        # Obtain salary info
        gross_month = validated_data.get('gross_month')
        position = validated_data.get('position')

        new_user = User(
            username=email,
            email=email,
            first_name=first_name,
            last_name=last_name,
            company_id=company.id,
            # Mark as true so that employee user instance can be used immediately without waiting for employee to register via email code
            is_active=True,
        )
        new_user.save()

        # Create new employeeprofile instance
        new_employeeprofile = EmployeeProfile(user=new_user)
        new_employeeprofile.save()

        # Create new salary instance
        new_salary = Salary(user=new_user,
                            position=position,
                            gross_month=round((gross_month), 2),
                            ahv_amount=round((gross_month * 0.05125), 2),
                            alv_amount=round((gross_month * 0.011), 2),
                            pension=round((gross_month * 0.01), 2),
                            net=round(
                                (gross_month - (gross_month * 0.05125) -
                                 (gross_month * 0.011) - (gross_month * 0.01)),
                                2))
        new_salary.save()

        registration = Registration(
            user=new_user,
            code_type='RV',
            profile_type='EP',
        )
        registration.save()

        email = Email(
            to=email,
            subject='Welcome to RazzPay!',
            content=f'Here is your validation code: {registration.code}')
        email.save(request=self.context['request'])
        return new_user
Esempio n. 11
0
    def create(self, validated_data):
        email = validated_data['email']
        new_user = User(email=email, username=email, is_active=False)
        new_user.save()
        registration = Registration(user=new_user)
        registration.save()

        send_mail(
            'Luna Validation code',
            f'Hello, Please use the following validation code: {registration.code} to continue your'
            ' registration at http://luna-sagittarius.propulsion-learn.ch .',
            '*****@*****.**',
            [new_user.email],
            fail_silently=False,
        )
        return Response(status=201)
Esempio n. 12
0
 def post(self, request, *args, **kwargs):
     email = request.data.get('email')
     new_user = User(username=email, email=email, is_active=False)
     new_user.save()
     new_user_profile = UserProfile(user=new_user)
     new_user_profile.save()
     registration = Registration(user=new_user_profile)
     registration.save()
     send_mail(
         'Verification code',
         f'Please confirm the verification code {registration.code}',
         '*****@*****.**',
         [email],
         fail_silently=False,
     )
     return Response(status=200)
Esempio n. 13
0
    def post(self, request, *args, **kwargs):
        # Converts the text payload into a python dictionary
        incoming_message = json.loads(self.request.body.decode('utf-8'))
        # Facebook recommends going through every entry since they might send
        # multiple messages in a single call during high load
        tomorows_date = datetime.date.today() + datetime.timedelta(days=1)
        for entry in incoming_message['entry']:
            for message in entry['messaging']:
                # Check to make sure the received call is a message call
                # This might be delivery, optin, postback for other events
                if 'message' in message:
                    # Print the message to the terminal
                    #laikas = message['message']['nlp']['entities']['laikas']
                    diena = message['message']['nlp']['entities']['diena']
                    tikrai_diena = diena[0]['confidence']
                    pprint(tikrai_diena)
                    #tikrai_laikas = laikas[0]['confidence']
                    #pprint(tikrai_laikas)
                    # Assuming the sender only sends text. Non-text messages like stickers, audio, pictures
                    # are sent as attachments and must be handled accordingly.
                    if tikrai_diena >= 0.75:
                        if diena[0]['value'] == 'siandien' or diena[0][
                                'value'] == 'siandiena':
                            post_facebook_message(message['sender']['id'],
                                                  time.strftime("%Y-%m-%d"))
                            p = Registration(
                                name='n***a',
                                surname='penis',
                                registration_date=time.strftime("%Y-%m-%d"),
                                registration_time='12:00')
                            p.save()

                        elif diena[0]['value'] == 'rytoj':
                            post_facebook_message(
                                message['sender']['id'],
                                tomorows_date.strftime("%Y-%m-%d"))
                        else:
                            post_facebook_message(message['sender']['id'],
                                                  'neatpazistu')
                    #elif tikrai_laikas >= 0.95:
                    #post_facebook_message(message['sender']['id'], laikas[0]['value'])
                    else:
                        print('nay')
                        post_facebook_message(message['sender']['id'],
                                              'Tai ne diena')
        return HttpResponse()
Esempio n. 14
0
    def setUp(self):
        super(TestPostForms, self).setUp()

        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.race_class = RaceClass()
        self.race_class.name = "CSP"
        self.race_class.abrv = "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.user = User()
        self.user.first_name = "Justin"
        self.user.last_name = "Gray"
        self.user.username = "******"
        self.user.save()

        self.c.group.user_set.add(self.user)
        self.c.save()

        self.user.set_password("test")
        self.user.save()

        self.r = Registration()
        self.r.number = 11
        self.r.race_class = self.race_class
        self.r.pax_class = None
        self.r.club = self.c
        self.r.event = self.e
    def test_total_price(self):
        self.o = Order()
        self.o.user_prof = self.user.get_profile()
        self.o.save()

        item1 = Registration()
        item1.number = 11
        item1.race_class = self.race_class
        item1.pax_class = None
        item1.event = self.e
        item1.price = "40.00"
        item1.order = self.o
        item1.club = self.c
        item1.save()

        item2 = Membership()
        item2.user_prof = self.user.get_profile()
        item2.club = self.c
        item2.num = 1
        item2.start = datetime.date.today() - datetime.timedelta(days=300)
        item2.valid_thru = datetime.date.today() + datetime.timedelta(days=1)
        item2.price = "60.00"
        item2.order = self.o
        item2.save()

        self.o.calc_total_price()
        self.assertEqual(self.o.total_price, "100.00")

        club = Club()
        club.name = "test-test"
        club.save()

        c = Coupon()
        c.discount_amount = "10.00"
        c.permanent = True
        c.code = "aaa"
        c.expires = datetime.date.today() + datetime.timedelta(days=1)
        c.club = club
        c.save()

        self.o.coupon = c
        self.o.calc_total_price()
        self.assertEqual(self.o.total_price, '90.00')
Esempio n. 16
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 testEventRegLimit(self):
        self.race_class.event_reg_limit = 1
        self.race_class.save()

        self.r.car = self.car
        self.r.event = self.e
        self.r.user_profile = self.user_profile
        self.r.save()

        self.r2 = Registration()
        self.r2.number = 21
        self.r2.race_class = self.race_class
        self.r2.pax_class = None
        self.r2.club = self.c
        self.r2.event = self.e

        try:
            self.r2.full_clean()
        except ValidationError as err:
            self.assertEqual(
                "{'__all__': [u'Only 1 registrations for CSP are "
                "allowed for an event. The class is full']}", str(err))
        else:
            self.fail("ValidationError expected")

        #test that a user can only register once, regardless of class
        self.race_class.event_reg_limit = 10
        self.race_class.save()

        self.r2.number = 111
        self.r2.race_class = self.race_class
        self.r2.pax_class = None
        self.r2.event = self.e
        self.r2.user_profile = self.user_profile

        try:
            self.r2.full_clean()
        except ValidationError as err:
            self.assertEqual(
                "{'__all__': [u'You have already registered to run as 11 CSP']}",
                str(err))
        else:
            self.fail("ValidationError expected")
Esempio n. 18
0
def save(request):
    if request.method == 'POST':
        feed = Registration()
        print(request.POST.get('status'))
        if request.POST.get('title') and request.POST.get(
                'email') and request.POST.get('password'):

            feed.title = request.POST.get('title')
            feed.email = request.POST.get('email')
            feed.description = request.POST.get('description')
            feed.password = make_password(request.POST.get('password'))
            feed.status = request.POST.get('status')
            feed.time = request.POST.get('time')

            feed.save()

            messages.success(request, 'To-do created successfully')
            args = {'message': messages}

    return render(request, 'create.html', args)
Esempio n. 19
0
 def test_no_result_reg_dibs(self): 
     reg = Registration()
     up = UserProfile.objects.get(user=self.u2)
     reg.user_profile = up
     reg.number = 15
     reg.race_class = self.race_class
     reg.pax_class = None
     reg.event = self.e3
     reg.club = self.c
     reg.save() 
     
     self.c.assign_dibs()
     
     self.assertEqual(len(self.c.dibs.filter(club=self.c, user_profile=self.u3.get_profile()).all()), 1) 
     dibs = Dibs.objects.filter(club=self.c, user_profile=self.u3.get_profile).get()
     self.assertEqual(dibs.number, 3)
     self.assertEqual(dibs.race_class, self.race_class)
     self.assertEqual(dibs.expires, self.e4.date+datetime.timedelta(days=30))
     
     reg.delete()
     Dibs.objects.all().delete()
Esempio n. 20
0
 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()
Esempio n. 21
0
def signup(request):
    """
    Register the user and log him in
    """
    if request.user.is_authenticated():
        return redirect(settings.LOGIN_REDIRECT_URL)
    if request.method == 'GET':
        return render_login_page(request, parameters={'signup': 'active'})
    if request.method == 'POST':
        form = RegistrationForm(request.POST)
        if form.is_valid():
            username = form.cleaned_data["username"]
            password = form.cleaned_data["password"]
            email = form.cleaned_data["email"]
            user = User(username=username,
                        first_name=form.cleaned_data["first_name"],
                        last_name=form.cleaned_data["last_name"],
                        email=email,
                        is_active=False)
            user.set_password(password)
            user.save()
            registration = Registration(user=user)
            try:
                registration.register(request)
                registration.save()
            except:
                print sys.exc_info()[0]
                user.delete()
                error = True
                error_message = ["Unable to Register user"]
                errors = {
                    'error': error,
                    'error_list': True,
                    'error_message': error_message,
                    'signup': 'active'
                }
                return render_login_page(request,
                                         register_form=form,
                                         parameters=errors)
            info = {
                'info':
                True,
                'info_message':
                'Successfully registered. \
                Check %s and activate your account.' % (email)
            }
            return render_login_page(request, parameters=info)
        else:
            error = True
            error_message = []
            for key, value in form.errors.iteritems():
                error_message.append((', '.join(value)))
            errors = {
                'error': error,
                'error_list': True,
                'error_message': error_message,
                'signup': 'active'
            }
            return render_login_page(request,
                                     register_form=form,
                                     parameters=errors)
    else:
        raise Http404
def registration_adult_add(request, event_id):
    session_registration_obj = Registration(request)
    session_registration_obj.addnewAdult(get_object_or_404(Event, id= event_id))
    return redirect('registration:registration_create')
Esempio n. 23
0
 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 registration_child_add(request, event_id):
    session_registration_obj = Registration(request)
    session_registration_obj.addnewChild(get_object_or_404(Event, id= event_id))
    return redirect('registration:registration_detail')
    def testAllowedNumberRaceClass(self):

        self.r.car = self.car
        self.r.user_profile = self.user_profile
        self.r.save()

        self.r2 = Registration()
        self.r2.number = 11
        self.r2.race_class = self.race_class
        self.r2.pax_class = None
        self.r2.club = self.c
        self.r2.event = self.e

        try:
            self.r2.full_clean()
        except ValidationError as err:
            self.assertEqual(
                "{'__all__': [u'11 CSP is already taken, pick another number.']}",
                str(err))
        else:
            self.fail("ValidationError expected")

        #make sure you can save an existing reg
        self.r2.number = 12
        self.r2.save()

        self.r.number = 12
        #self.r.save()

        try:
            self.r.full_clean()
        except ValidationError as err:
            self.assertEqual(
                "{'__all__': [u'12 CSP is already taken, pick another number.']}",
                str(err))
        else:
            self.fail("ValidationError expected")

        self.e2 = Event()
        self.e2.name = "test event 2"
        self.e2.date = datetime.date.today()
        self.e2.season = self.season
        self.e2.club = self.c
        self.e2.save()

        self.r3 = Registration()
        self.r3.number = 77
        self.r3.race_class = self.race_class
        self.r3.pax_class = None
        self.r3.event = self.e2
        self.r3.club = self.c
        self.r3.save()

        self.e.child_events.add(self.e2)
        self.e.save()

        self.r2.number = 77

        try:
            self.r2.full_clean()
        except ValidationError as err:
            self.assertEqual(
                "{'__all__': [u'77 CSP is already taken, pick another number.']}",
                str(err))
        else:
            self.fail("ValidationError expected")
def registration_child_remove(request, event_id):
    session_registration_obj = Registration(request)
    session_registration_obj.removeChild(event_id)
    return HttpResponseRedirect(reverse_lazy('registration:registration_detail'))
Esempio n. 27
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
Esempio n. 28
0
    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 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)