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)