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)
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))
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")
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
def setUp(self): self.c = Club() self.c.name = "test club" self.c.full_clean() self.c.save() self.season = Season() self.season.club = self.c self.season.year = 2011 self.season.save() self.e = Event() self.e.name = "test event" self.e.date = datetime.date.today() self.e.season = self.season self.e.club = self.c self.e.save() self.sess = Session() self.sess.name = "AM" self.sess.event = self.e self.sess.club = self.c self.sess.save() self.classes = ["A", "B", "C", "D", "E", "F", "G", "H"] self.paxes = [1.0, .98, .96, .94, .92, .90, .88, .86] for klass, pax in zip(self.classes, self.paxes): self.race_class = RaceClass() self.race_class.name = klass self.race_class.pax = pax self.race_class.club = self.c self.race_class.save() for i in range(0, 10): self.r = Registration() self.r.number = i self.r.race_class = self.race_class self.r._anon_f_name = "%s%d"%(self.race_class.name, i) self.r.pax_class = None self.r.event = self.e self.r.club = self.c self.r.save() #make two regs with empty runs for each class if self.race_class.name!="H" and i < 8: #one race class with no results self.result = Result() self.result.reg = self.r self.result.session = self.sess self.result.club = self.c self.result.save() for j in range(0, 3): run = Run() run.base_time = 100.0-i-j #91.0 is lowest raw time (*0.88 for index) run.result = self.result run.club = self.c run.save()
def test_pax_class_one_result(self): self.race_class = RaceClass() self.race_class.name = "Pro" self.race_class.abrv ="X" self.race_class.pax = 1.0 self.race_class.pax_class=True self.race_class.club = self.c self.race_class.save() for i, pax_name in zip(range(0, 7), self.classes): rc = RaceClass.objects.filter(name=pax_name).get() self.r = Registration() self.r.number = 10*(1+i) self.r.race_class = rc self.r._anon_f_name = "%s_%d"%(self.race_class.name, i) self.r.pax_class = self.race_class self.r.event = self.e self.r.club = self.c self.r.save() #make regs with runs for each class if rc.name!="H": self.result = Result() self.result.reg = self.r self.result.session = self.sess self.result.club = self.c self.result.save() for j in range(0, 3): run = Run() run.base_time = 100.0-i-j run.result = self.result run.club = self.c run.save() race_classes = self.e.calc_results() self.assertEqual([u"A", u"B", u"C", u"D", u"E", u"F", u"G", u"Pro"], [rc.name for rc in race_classes]) #make sure the results come back sorted for rc, regs in race_classes.iteritems(): #all race_classes should have 8 regs in the results self.assertEqual(regs, sorted(regs, key=lambda x: x.total_index_time)) if rc.name != "Pro": self.assertEqual(class_point_ladder[:8], [reg.class_points for reg in regs]) self.assertEqual(8, len(regs)) else: self.assertEqual(class_point_ladder[:7], [reg.class_points for reg in regs]) self.assertEqual(7, len(regs)) regs = self.e.get_results() self.assertEqual(regs[0].total_index_time, (91.0)*.88) self.assertEqual(index_point_ladder[:63], [reg.index_points for reg in regs])
def 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)
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
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)
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)
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()
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')
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")
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)
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()
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()
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')
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'))
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 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)