def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.full_clean()
self.c.save()
self.user1 = User()
self.user1.first_name = "Justin"
self.user1.last_name = "Gray"
self.user1.username = "******"
self.user1.save()
self.user2 = User()
self.user2.first_name = "Sirius"
self.user2.last_name = "Gray"
self.user2.username = "******"
self.user2.save()
m= Membership()
m.user_prof = self.user1.get_profile()
m.club = self.c
m.num = 1
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today()+datetime.timedelta(days=1)
m.paid = True
m.full_clean()
m.save()
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.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 = "sirius"
self.user2.last_name = "gray"
self.user2.username = "******"
self.user2.save()
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.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 = "sirius"
self.user2.last_name = "gray"
self.user2.username = "******"
self.user2.save()
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.full_clean()
self.c.save()
self.user1 = User()
self.user1.first_name = "Justin"
self.user1.last_name = "Gray"
self.user1.username = "******"
self.user1.save()
self.user2 = User()
self.user2.first_name = "Sirius"
self.user2.last_name = "Gray"
self.user2.username = "******"
self.user2.save()
m = Membership()
m.user_prof = self.user1.get_profile()
m.club = self.c
m.num = 1
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today() + datetime.timedelta(days=1)
m.paid = True
m.full_clean()
m.save()
def test_coupon_notification(self):
user = User()
user.first_name = "justin"
user.last_name = "gray"
user.username = "******"
user.email = "*****@*****.**"
user.save()
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.user_prof = user.get_profile()
c.save()
#make sure notification email was sent
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, u'New example.com coupon')
def get(self, request):
context = {
'totalprojects':
Project.project_query().get('allprojects').count(),
'totalusers': User.user_query().get('allusers').count(),
'allocatepercent': employeesallocated().get('allocatepercent'),
'allocatedusers': User.user_query().get('allusers').count(),
'failpercent': employeesallocated().get('failpercent'),
'finishpercent': employeesallocated().get('finishpercent'),
'wellpercent': employeesallocated().get('wellpercent')
}
return render(request, 'dashboard.html', context)
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 = 0.875
self.race_class.club = self.c
self.race_class.save()
self.e = Event()
self.e.name = "test event"
self.e.date = datetime.date.today()
self.e.season = self.season
self.e.club = self.c
self.e.save()
self.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 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 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 valid_email(request):
"""
Return true if the email is valid and false otherwise. Used exclusively for form validation.
"""
email = request.GET.get('email')
user = request.user
try:
User.valid_email(email, user)
valid = True
except ValidationError:
valid = False
return ajax_http(True, extra_json={'valid': valid})
def test_coupon_notification(self):
user = User()
user.first_name = "justin"
user.last_name = "gray"
user.username = "******"
user.email = "*****@*****.**"
user.save()
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.user_prof = user.get_profile()
c.save()
#make sure notification email was sent
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject,
u'New example.com coupon')
class Meta(UserCreationForm.Meta):
fields = [
User.get_email_field_name(),
"first_name",
"last_name",
"password1",
"password2",
]
labels = {
User.get_email_field_name(): _("Email"),
"first_name": _("First Name"),
"last_name": _("Last Name"),
"password1": _("Password"),
"password2": _("Confirm Password"),
}
def valid_email(request):
"""
Return true if the email is valid and false otherwise. Used exclusively for form validation.
"""
email = request.GET.get('email')
user = request.user
try:
User.valid_email(email, user)
valid = True
except ValidationError:
valid = False
return ajax_http(True,
extra_json={'valid': valid})
def create_payment_intent(request):
if request.method == 'POST':
user = User.get_user(request.session['user'])
amount = int(request.data['amount'])
currency = request.data['currency']
coupon = request.data['coupon']
stripe_customer_id = None
stripe.api_key = settings.STRIPE_PRIVATE_KEY
metadata = {
'payment_flow': 'any description here ',
'booking_type': 'instant_booking',
'listing_price_at_booking_time': 'add listing price here ',
'lesson_duration': '60 mins',
}
intent = stripe.PaymentIntent.create(
amount=(amount * 100),
currency=currency,
metadata=metadata,
receipt_email=user.email,
customer=stripe_customer_id,
description='instant booking amount paid by ' +
user.key.urlsafe().decode(),
)
return Response({
'status': status.HTTP_200_OK,
'intent_id': intent.id,
'client_secret': intent.client_secret
})
def authenticate(self, email=None, password=None, email_confirm_link=None):
"""
This authentication method tries to look up the user by both email address and email confirmation link.
We want to log users in after they click the email confirmation link, but the server won't have their password
after they click it. Thus, we want to be able to authenticate a user solely based on that email link object.
"""
user = None
if email and password:
period_found = False
at_found = False
for char in email:
if char == '@':
at_found = True
elif char == '.':
period_found = True
# If an email address was submitted, look up user via unique email
if period_found and at_found:
user = User.get_user_by_email(email)
if not (user and user.check_password(password)):
user = None
elif email_confirm_link:
user = email_confirm_link.get_user_from_link()
else:
# Run the default password hasher once to reduce the timing
# difference between an existing and a non-existing user (Django ticket #20760).
make_password(password)
return user
def handle(self, *args, **options):
if options['truncate']:
User.objects.all().delete()
with open(SEED_FILE) as f:
friends = json.load(f)
bulk_friend = []
for friend in friends:
bulk_friend.append(
User(
username=friend['domain'],
email='*****@*****.**',
password=make_password('52412630aA'),
first_name=friend['first_name'],
last_name=friend['last_name'],
city=friend['city'],
country='Беларусь',
number_phone=friend['id'],
avatar=friend['avatar']
)
)
self.stdout.write(f"Friends {friend['first_name']} processed")
User.objects.bulk_create(bulk_friend)
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 test_fields_required(self):
form = SignUpForm()
for field in (
User.get_email_field_name(),
"first_name",
"last_name",
"password1",
"password2",
):
self.assertTrue(form.fields[field].required)
def allocationchart_query():
projects = []
allocation = []
for project in Project.project_query().get('allprojects')[:10]:
allocation.append(int(ProjectAllocation.objects.filter(project_id=project.id).count()))
projects.append(project.name)
allocation.append(User.user_query().get('allusers').count())
context = {
'projects': projects,
'allocation': allocation
}
return context
def get_payment_method(request):
if request.method == 'GET':
user = User.get_user(request.session['user'])
stripe.api_key = settings.STRIPE_PRIVATE_KEY
user_cards = None
if user.stripe_customer_id is not None:
response = stripe.Customer.retrieve(user.stripe_customer_id)
user_cards = response.sources.data
return Response({
'status': status.HTTP_200_OK,
'user_cards': user_cards
})
def create(self, validated_data):
user = User(
name=validated_data['name'],
contact=validated_data['contact'],
txn_id=validated_data['txn_id'],
email=validated_data['email'],
username=validated_data['username'],
# first_name=validated_data['first_name'],
# last_name=validated_data['last_name'],
college=validated_data['college'],
branch=validated_data['branch'],
course=validated_data['course'],
sem=validated_data['sem'],
address=validated_data['address'],
pay_mode=validated_data['pay_mode'],
)
# if User.objects.filter(contact=contact).exists():
# raise serializers.ValidationError('An account with this email already exists.')
# return Response(content, status=status.HTTP_409_CONFLICT)
user.set_password(validated_data['password'])
user.save()
send_sms(user.contact)
return user
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 register(request):
if request.method == 'POST': # If the form has been submitted...
form = RegistrationForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
post_data = request.POST
#:import ipdb;ipdb.set_trace()
rec = User(username=post_data["username"],
first_name=post_data["first_name"],
last_name=post_data['last_name'],
email=post_data['email'],
date_of_birth=post_data['dob_dd']+'/'+post_data['dob_mm']+'/'+post_data['dob_yy'],
sex=post_data['sex'])
rec.save()
return HttpResponseRedirect('/registration/list/') # Redirect after POST
else:
form = RegistrationForm() # An unbound form
return render(request, 'registration/registration.html', {
'form': form,
})
def get_balance(request):
if request.method == 'GET':
user = User.get_user(request.session['user'])
stripe.api_key = settings.STRIPE_PRIVATE_KEY
if user.stripe_connect_account_id is None:
all_transfers = None
else:
all_transfers = stripe.Transfer.list(
destination=user.stripe_connect_account_id, limit=1000)
return Response({
'status': status.HTTP_200_OK,
'all_transfers': all_transfers
})
def get_payout_method(request):
if request.method == 'GET':
user = User.get_user(request.session['user'])
stripe.api_key = settings.STRIPE_PRIVATE_KEY
if user.stripe_connect_account_id is None:
acct = None
else:
acct = stripe.Account.retrieve(user.stripe_connect_account_id, )
return Response({
'status':
status.HTTP_200_OK,
'acct':
acct.external_accounts.data if acct != None else []
})
def register_parent_app(request, phone_no):
data = {}
response = 0
if request.method == 'POST':
try:
registration_id = request.data["gid"]
print str(registration_id[0])
profile_type = request.data["type"]
print profile_type[0]
google_registration_id = GoogleRegistrationId.objects.create(registration_id=registration_id[0])
user_profile = UserProfile.objects.create(regid=google_registration_id, type=profile_type[0])
r = User(phone_no=phone_no, user_profile=user_profile)
r.save()
response = 1
message = "Saved to database"
except Exception as e:
print e
response = 0
message = e.message
data.update({
'response': response,
'message': message
})
return Response(data)
def delete_payout_method(request):
if request.method == 'POST':
user = User.get_user(request.session['user'])
stripe.api_key = settings.STRIPE_PRIVATE_KEY
stripe.Account.delete_external_account(request.data['acc_id'],
request.data['bank_id'])
acct = None
if user.stripe_connect_account_id is not None:
acct = stripe.Account.retrieve(user.stripe_connect_account_id, )
return Response({
'status': status.HTTP_200_OK,
'acct': acct.external_accounts.data
})
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
email_field = User.get_email_field_name()
self.fields[email_field].validators.extend((
validators.HTML5EmailValidator(),
validators.validate_confusables_email,
validators.CaseInsensitiveUnique(User, email_field,
"This email is unavailable"),
))
self.label_suffix = ""
# This overrides the default labels set by UserCreationForm
for field, label in self._meta.labels.items():
self.fields[field].label = label
for field in self._meta.fields:
self.fields[field].required = True
def create(self, validated_data):
user = User(
name=validated_data['name'],
contact=validated_data['contact'],
email=validated_data['email'],
college=validated_data['college'],
branch=validated_data['branch'],
course=validated_data['course'],
sem=validated_data['sem'],
city=validated_data['city']
)
user.otp = random.randint(100000,999999)
user.set_password(validated_data['password'])
user.username = str(user.contact)
user.save()
message = 'Your OTP is '+ str(user.otp)
send_sms(user.contact, message)
return user
def add_payment_method(request):
if request.method == 'POST':
user = User.get_user(request.session['user'])
stripe.api_key = settings.STRIPE_PRIVATE_KEY
if user.stripe_customer_id is None:
response = stripe.Customer.create(
email=user.email,
name=user.first_name,
description=user.first_name + ' ' + user.last_name,
)
user.stripe_customer_id = response.id
user.put()
source = stripe.Customer.create_source(
user.stripe_customer_id, source=request.data['card_token'])
return Response({
'status': status.HTTP_200_OK,
'user': to_json_ndb(user)
})
def create(self, validated_data):
user = User(email=validated_data['email'],
username=validated_data['username'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name'],
contact=validated_data['contact'],
college_name=validated_data['college_name'],
branch_name=validated_data['branch_name'],
sem=validated_data['sem'],
address=validated_data['address'])
user.set_password(validated_data['password'])
user.save()
return user
def add_bank_account(request):
if request.method == 'POST':
user = User.get_user(request.session['user'])
if not user.stripe_connect_account_id:
country = 'GB'
stripe.api_key = settings.STRIPE_PRIVATE_KEY
acct = stripe.Account.create(
country=country,
type="custom",
email=user.email,
legal_entity={
"first_name": user.first_name,
"last_name": user.last_name,
"type": 'individual',
"dob": {
"day": '1',
"month": '11',
"year": '2000'
}
},
tos_acceptance={
"date": datetime.datetime.now(),
"ip": "119.156.76.23"
# "ip": self.request.remote_addr
},
metadata={
'slug': user.key.urlsafe().decode(),
'email': user.email,
},
)
user.stripe_connect_account_id = acct.id
user.stripe_connect_country = country
user.put()
acct = stripe.Account.create_external_account(
user.stripe_connect_account_id,
external_account=request.data['bank_token'])
return Response({
'status': status.HTTP_200_OK,
'account': acct,
})
def userallocatedinproject():
if User.user_query().get('allusers').count() and Project.project_query().get(
'allprojects').count():
context = {
'allocatedusers': User.objects.filter(id__in=ProjectAllocation.objects.all().values('user_id')),
'allocatepercent': (User.objects.filter(id__in=ProjectAllocation.objects.all().values('user_id')).count() / User.user_query().get(
'allusers').count()) * 100,
'failpercent': (Project.objects.filter(status='closed').count() / Project.project_query().get(
'allprojects').count()) * 100,
'finishpercent': (Project.objects.filter(status='created').count() / Project.project_query().get(
'allprojects').count()) * 100,
'wellpercent': (Project.objects.filter(status='Underprogress').count() / Project.project_query().get(
'allprojects').count()) * 100
}
else:
context = {
'allocatedusers': User.objects.filter(id__in=ProjectAllocation.objects.all().values('user_id')),
'allocatepercent': (User.objects.filter(id__in=ProjectAllocation.objects.all().values('user_id')).count() / 1) * 100,
'failpercent': (Project.objects.filter(status='closed').count() / 1) * 100,
'finishpercent': (Project.objects.filter(status='created').count() / 1) * 100,
'wellpercent': (Project.objects.filter(status='Underprogress').count() / 1) * 100
}
return context
def user_registration(request):
"""
End-point for user registration
"""
# Validating data through serializer
serializer = UserRegistrationSerializer(data = request.data)
if not serializer.is_valid():
logger.debug('USER REGISTRATION: Invalid data. Errors: %s' % serializer.errors)
# Return error response if request data is invalid
return Response(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
# Creating User instance and assigning data
user = User()
user.name = serializer.data['name']
user.email = serializer.data['email']
user.password = make_password(serializer.data['password'])
user.address = serializer.data['address']
# Saving user object to database
try:
user.save()
logger.info("USER REGISTRATION: User object saved successfully. \
User email: %s, User ID: %s" % (user.email, user.id))
except Exception as e:
logger.debug("USER REGISTRATION: User already registered with email id %s. \
Error: %s" % (serializer.data['email'], e))
return Response({'detail':'User already registered with the provided email'},
status = status.HTTP_400_BAD_REQUEST)
# Calling save geo details task to run in background
save_geo_details.apply_async([user.id, serializer.data['address']])
return Response({'message':'User registered successfully', 'user_id':user.id},
status=status.HTTP_201_CREATED)
class TestOrder(unittest.TestCase):
def tearDown(self):
clear_db()
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.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 = "sirius"
self.user2.last_name = "gray"
self.user2.username = "******"
self.user2.save()
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')
class TestRegistration(unittest.TestCase):
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.full_clean()
self.c.save()
self.season = Season()
self.season.club = self.c
self.season.year = 2011
self.season.save()
self.race_class = RaceClass()
self.race_class.name = "CSP"
self.race_class.abrv = "CSP"
self.race_class.pax = 0.875
self.race_class.club = self.c
self.race_class.save()
self.e = Event()
self.e.name = "test event"
self.e.date = datetime.date.today()
self.e.season = self.season
self.e.club = self.c
self.e.save()
self.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 tearDown(self):
clear_db()
def test_default_pax_class(self):
pax_class = RaceClass()
pax_class.name = "Street Tire"
pax_class.abrv = "T"
pax_class.pax = 1
pax_class.club = self.c
pax_class.pax_class = True
pax_class.hidden = True
pax_class.save()
other_pax_class = RaceClass()
other_pax_class.name = "Pro"
other_pax_class.abrv = "X"
other_pax_class.pax = 1
other_pax_class.club = self.c
other_pax_class.pax_class = True
other_pax_class.hidden = False
other_pax_class.save()
race_class = RaceClass()
race_class.name = "HS"
race_class.abrv = "HS"
race_class.pax = 0.5
race_class.club = self.c
race_class.default_pax_class = pax_class
race_class.save()
self.r.race_class = race_class
self.r.save()
self.assertEqual(self.r.pax_class, pax_class)
# set it back to CSP
self.r.race_class = self.race_class
self.r.save()
self.assertEqual(self.r.pax_class, None)
# make sure pax_class does not change
self.r.pax_class = other_pax_class
self.r.save()
self.assertEqual(self.r.pax_class, other_pax_class)
self.r.race_class = race_class
self.r.save()
self.assertEqual(self.r.pax_class, other_pax_class)
def test_calc_times_empty_results(self):
self.r.save()
self.r.calc_times()
self.assertEqual(self.r.total_raw_time, 0)
self.assertEqual(self.r.total_index_time, 0)
def test_calc_times(self):
self.r.save()
sess = Session()
sess.name = "AM"
sess.event = self.e
sess.club = self.c
sess.save()
res = Result()
res.reg = self.r
res.session = sess
res.club = self.c
res.save()
r = Run()
r.base_time = 10.0
r.result = res
r.club = self.c
r.save()
res = Result()
res.reg = self.r
res.session = sess
res.club = self.c
res.save()
r = Run()
r.base_time = 10.0
r.result = res
r.club = self.c
r.save()
self.r.save()
self.r.calc_times()
self.assertEqual(self.r.total_raw_time, 20.0)
self.assertEqual(self.r.total_index_time, self.r.total_raw_time * self.race_class.pax)
def testAnon(self):
self.r._anon_f_name = "Justin"
self.r._anon_l_name = "Gray"
self.r._anon_car = "1990 Mazda Miata"
self.r.save()
self.assertEqual("Justin", self.r.first_name)
self.assertEqual("Gray", self.r.last_name)
self.assertEqual("1990 Mazda Miata", self.r.car_name)
self.r.associate_with_user(self.user2.username)
self.r.save()
self.assertEqual("Eli", self.r.first_name)
self.assertEqual("Gray", self.r.last_name)
self.assertEqual("1990 Mazda Miata", self.r.car_name)
def testWithCar(self):
self.r.car = self.car
self.r.user_profile = self.user_profile
self.r.save()
self.assertEqual("Justin", self.r.first_name)
self.assertEqual("Gray", self.r.last_name)
self.assertEqual("1990 Mazda Miata", self.r.car_name)
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 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 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 testCarDeleteFromReg(self):
"""Check to make sure reg_car gets set to null if a car gets deleted"""
self.r.car = self.car
self.r.save()
self.assertEqual(self.r.car, self.car)
self.car.delete()
reg = Registration.objects.filter(number=11).get()
self.assertIsNone(reg.car)
def testMoveToBumpClass(self):
bump_class = RaceClass()
bump_class.name = "Index"
bump_class.pax = 1.0
bump_class.club = self.c
bump_class.save()
self.r.bump_class = bump_class
self.r.save()
self.assertEqual(self.r.race_class, self.race_class)
self.assertEqual(self.r.bump_class, bump_class)
def testMakeAssocRegs(self):
e2 = Event()
e2.name = "test event 2"
e2.date = datetime.date.today()
e2.season = self.season
e2.club = self.c
e2.save()
self.e.child_events.add(e2)
self.e.save()
self.r.make_assoc_regs()
regs = Registration.objects.filter(event=e2).all()
self.assertEqual(len(regs), 1)
def testUpdateAssocRegs(self):
e2 = Event()
e2.name = "test event 2"
e2.date = datetime.date.today()
e2.season = self.season
e2.club = self.c
e2.save()
self.e.child_events.add(e2)
self.e.save()
self.r.make_assoc_regs()
self.r.number = 10
self.r.save()
self.r.update_assoc_regs()
reg = Registration.objects.filter(event=e2).get()
self.assertEqual(reg.number, self.r.number)
def test_coupon_is_valid(self):
user = User()
user.first_name = "justin"
user.last_name = "gray"
user.username = "******"
user.email = "*****@*****.**"
user.save()
user2 = User()
user2.first_name = "sirius"
user2.last_name = "gray"
user2.username = "******"
user2.save()
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()
o = Order()
o.coupon = c
o.user_prof = user.get_profile()
o.save()
self.assertTrue(c.is_valid(user))
c.uses_left = 0
self.assertTrue(c.is_valid(user))
c.expires = datetime.date.today() - datetime.timedelta(days=1)
self.assertTrue(c.is_valid(user))
c.permanent = False
self.assertFalse(c.is_valid(user))
c.expires = datetime.date.today() + datetime.timedelta(days=1)
c.uses_left = 1
self.assertTrue(c.is_valid(user))
c.uses_left = 0
self.assertFalse(c.is_valid(user))
c.uses_left = 1
c.user_prof = user.get_profile()
self.assertFalse(c.is_valid(user2))
c.user_prof = None
c.single_use_per_user = True
self.assertFalse(c.is_valid(user))
class TestRegistration(unittest.TestCase):
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.full_clean()
self.c.save()
self.season = Season()
self.season.club = self.c
self.season.year = 2011
self.season.save()
self.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 tearDown(self):
clear_db()
def test_default_pax_class(self):
pax_class = RaceClass()
pax_class.name = "Street Tire"
pax_class.abrv = "T"
pax_class.pax = 1
pax_class.club = self.c
pax_class.pax_class = True
pax_class.hidden = True
pax_class.save()
other_pax_class = RaceClass()
other_pax_class.name = "Pro"
other_pax_class.abrv = "X"
other_pax_class.pax = 1
other_pax_class.club = self.c
other_pax_class.pax_class = True
other_pax_class.hidden = False
other_pax_class.save()
race_class = RaceClass()
race_class.name = "HS"
race_class.abrv = "HS"
race_class.pax = .5
race_class.club = self.c
race_class.default_pax_class = pax_class
race_class.save()
self.r.race_class = race_class
self.r.save()
self.assertEqual(self.r.pax_class, pax_class)
#set it back to CSP
self.r.race_class = self.race_class
self.r.save()
self.assertEqual(self.r.pax_class, None)
#make sure pax_class does not change
self.r.pax_class = other_pax_class
self.r.save()
self.assertEqual(self.r.pax_class, other_pax_class)
self.r.race_class = race_class
self.r.save()
self.assertEqual(self.r.pax_class, other_pax_class)
def test_calc_times_empty_results(self):
self.r.save()
self.r.calc_times()
self.assertEqual(self.r.total_raw_time, 0)
self.assertEqual(self.r.total_index_time, 0)
def test_calc_times(self):
self.r.save()
sess = Session()
sess.name = "AM"
sess.event = self.e
sess.club = self.c
sess.save()
res = Result()
res.reg = self.r
res.session = sess
res.club = self.c
res.save()
r = Run()
r.base_time = 10.0
r.result = res
r.club = self.c
r.save()
res = Result()
res.reg = self.r
res.session = sess
res.club = self.c
res.save()
r = Run()
r.base_time = 10.0
r.result = res
r.club = self.c
r.save()
self.r.save()
self.r.calc_times()
self.assertEqual(self.r.total_raw_time, 20.0)
self.assertEqual(self.r.total_index_time,
self.r.total_raw_time * self.race_class.pax)
def testAnon(self):
self.r._anon_f_name = "Justin"
self.r._anon_l_name = "Gray"
self.r._anon_car = "1990 Mazda Miata"
self.r.save()
self.assertEqual("Justin", self.r.first_name)
self.assertEqual("Gray", self.r.last_name)
self.assertEqual("1990 Mazda Miata", self.r.car_name)
self.r.associate_with_user(self.user2.username)
self.r.save()
self.assertEqual("Eli", self.r.first_name)
self.assertEqual("Gray", self.r.last_name)
self.assertEqual("1990 Mazda Miata", self.r.car_name)
def testWithCar(self):
self.r.car = self.car
self.r.user_profile = self.user_profile
self.r.save()
self.assertEqual("Justin", self.r.first_name)
self.assertEqual("Gray", self.r.last_name)
self.assertEqual("1990 Mazda Miata", self.r.car_name)
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 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 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 testCarDeleteFromReg(self):
"""Check to make sure reg_car gets set to null if a car gets deleted"""
self.r.car = self.car
self.r.save()
self.assertEqual(self.r.car, self.car)
self.car.delete()
reg = Registration.objects.filter(number=11).get()
self.assertIsNone(reg.car)
def testMoveToBumpClass(self):
bump_class = RaceClass()
bump_class.name = "Index"
bump_class.pax = 1.0
bump_class.club = self.c
bump_class.save()
self.r.bump_class = bump_class
self.r.save()
self.assertEqual(self.r.race_class, self.race_class)
self.assertEqual(self.r.bump_class, bump_class)
def testMakeAssocRegs(self):
e2 = Event()
e2.name = "test event 2"
e2.date = datetime.date.today()
e2.season = self.season
e2.club = self.c
e2.save()
self.e.child_events.add(e2)
self.e.save()
self.r.make_assoc_regs()
regs = Registration.objects.filter(event=e2).all()
self.assertEqual(len(regs), 1)
def testUpdateAssocRegs(self):
e2 = Event()
e2.name = "test event 2"
e2.date = datetime.date.today()
e2.season = self.season
e2.club = self.c
e2.save()
self.e.child_events.add(e2)
self.e.save()
self.r.make_assoc_regs()
self.r.number = 10
self.r.save()
self.r.update_assoc_regs()
reg = Registration.objects.filter(event=e2).get()
self.assertEqual(reg.number, self.r.number)
class TestMembership(unittest.TestCase):
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.full_clean()
self.c.save()
self.user1 = User()
self.user1.first_name = "Justin"
self.user1.last_name = "Gray"
self.user1.username = "******"
self.user1.save()
self.user2 = User()
self.user2.first_name = "Sirius"
self.user2.last_name = "Gray"
self.user2.username = "******"
self.user2.save()
m = Membership()
m.user_prof = self.user1.get_profile()
m.club = self.c
m.num = 1
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today() + datetime.timedelta(days=1)
m.paid = True
m.full_clean()
m.save()
def tearDown(self):
clear_db()
def test_is_active_member(self):
self.assertTrue(self.c.is_active_member(self.user1))
self.assertFalse(self.c.is_active_member(self.user2))
m = Membership()
m.user_prof = self.user2.get_profile()
m.club = self.c
m.num = 2
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today()
m.full_clean()
m.save()
#make sure expired memberships don't report as active
self.assertFalse(self.c.is_active_member(self.user2))
def test_duplicate_id(self):
m = Membership()
m.user_prof = self.user2.get_profile()
m.club = self.c
m.num = 1
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today() + datetime.timedelta(days=1)
try:
m.full_clean()
m.save()
except ValidationError as err:
self.assertEqual(
str(err),
"{'__all__': [u'A member with that number already exists']}")
else:
self.fail("ValidationError expected")
def test_auto_increment_number(self):
m = Membership()
m.user_prof = self.user2.get_profile()
m.club = self.c
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today()
m.full_clean()
m.save()
self.assertEqual(m.num, 2)
def test_is_member(self):
up = self.user1.get_profile()
self.assertTrue(up.is_member(self.c))
class TestDibs(unittest.TestCase):
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 tearDown(self):
self.u3.delete()
self.u2.delete()
self.u1.delete()
self.s.delete()
self.c.delete()
def test_1_dibs(self):
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))
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 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_update_existing_dibs(self):
dibs = Dibs()
dibs.club = self.c
dibs.user_profile = self.u3.get_profile()
dibs.race_class = self.race_class
dibs.number = 3
dibs.duration = 30
dibs.expires = self.today+datetime.timedelta(days=5)
dibs.save()
dibs.created = self.today-datetime.timedelta(days=60)
dibs.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.duration, 60)
self.assertEqual(dibs.expires, self.e3.date+datetime.timedelta(days=60))
dibs.delete()
def test_dont_update_old_dibs(self):
dibs = Dibs()
dibs.club = self.c
dibs.user_profile = self.u1.get_profile()
dibs.race_class = self.race_class
dibs.number = 3
dibs.duration = 30
dibs.expires = self.today-datetime.timedelta(days=5)
dibs.save()
dibs.created = self.today-datetime.timedelta(days=60)
dibs.save()
self.c.assign_dibs()
dibs = Dibs.objects.filter(user_profile=self.u1.get_profile()).get()
self.assertEqual(dibs.expires, self.today-datetime.timedelta(days=5))
self.assertEqual(dibs.duration, 30)
def test_race_class_allow_dibs(self):
self.race_class.allow_dibs = False
self.race_class.save()
self.c.assign_dibs()
self.assertEqual(len(Dibs.objects.all()), 0)
def test_clean_dibs(self):
dibs = Dibs()
dibs.club = self.c
dibs.expires = datetime.date.today()-datetime.timedelta(days=10)
dibs.duration = 30
dibs.number = 99
dibs.race_class = self.race_class
dibs.user_profile = self.u2.get_profile()
dibs.save()
clean_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))
self.assertEqual(len(self.c.dibs.filter(club=self.c, user_profile=self.u2.get_profile()).all()), 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 register_user(request):
"""
Takes in the user registration data from the template, checks to make sure it's all valid, saves to model.
@param request: A HTTP request object.
@returns: A redirect to the new user's dashboard if successful, a re-render of the form if not.
"""
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
full_name = form.cleaned_data['full_name']
email = form.cleaned_data['email']
zipcode = form.cleaned_data['zipcode']
password = form.cleaned_data['password']
password_confirmation = form.cleaned_data['password_confirmation']
pick_up = form.cleaned_data['pick_up']
if full_name.isspace():
return render(request, 'registration/user_registration.html', {'form': form, 'email_not_unique': False, 'password': False, 'whitespace':True})
if (password == password_confirmation):
share_zone = ShareZone(request.POST['zipcode'])
share_zone.save()
user = User(full_name=full_name, email=email, password=password,
zipcode=zipcode, my_zone=share_zone, pick_up=pick_up)
user.set_password(request.POST['password'])
else:
return render(request, 'registration/user_registration.html', {'form': form, 'email_not_unique': False, 'password': True, 'whitespace':False})
try:
user.save()
except IntegrityError:
return (render(request, 'registration/user_registration.html', {'form': form, 'email_not_unique': True, 'password': False,"whitespace": False}))
"""
creates a community shed if one does not exists and sets up the relationship between the new user and shed
if the community shed for that zipcode already exists then just add relationship for the new user
"""
if not Sheds.objects.filter(shed_zipcode=zipcode, shed_type=1):
community_shed = Sheds.objects.create(shed_name='Community'+ str(zipcode), shed_type=1, shed_zipcode=zipcode)
community_shed.save()
member = ShedMember.objects.create(user=user, shed=community_shed, member_type=4)
member.save()
else:
community_shed = Sheds.objects.filter(shed_zipcode=zipcode, shed_type=1)[0]
member = ShedMember.objects.create(user=user, shed=community_shed, member_type=5)
member.save()
#create a home shed and relationship for the new user
home_shed = Sheds.objects.create(shed_zipcode=zipcode, shed_type=3, shed_name=user.email, shed_address=user.address)
home_shed.save()
membership = ShedMember.objects.create(user=user, shed=home_shed, member_type=4)
membership.save()
new_user = authenticate(email=email, password=password)
login(request, new_user)
return HttpResponseRedirect(reverse('home:get_started', args=()))
else:
#return HttpResponse(user_registration_form.errors) #Use this one to see where the form is failing validation.
return(render(request, 'registration/user_registration.html', {'form': form, 'email_not_unique': False}))
else:
return render(request, 'home/index')
class TestMembership(unittest.TestCase):
def setUp(self):
self.c = Club()
self.c.name = "test club"
self.c.full_clean()
self.c.save()
self.user1 = User()
self.user1.first_name = "Justin"
self.user1.last_name = "Gray"
self.user1.username = "******"
self.user1.save()
self.user2 = User()
self.user2.first_name = "Sirius"
self.user2.last_name = "Gray"
self.user2.username = "******"
self.user2.save()
m= Membership()
m.user_prof = self.user1.get_profile()
m.club = self.c
m.num = 1
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today()+datetime.timedelta(days=1)
m.paid = True
m.full_clean()
m.save()
def tearDown(self):
clear_db()
def test_is_active_member(self):
self.assertTrue(self.c.is_active_member(self.user1))
self.assertFalse(self.c.is_active_member(self.user2))
m= Membership()
m.user_prof = self.user2.get_profile()
m.club = self.c
m.num = 2
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today()
m.full_clean()
m.save()
#make sure expired memberships don't report as active
self.assertFalse(self.c.is_active_member(self.user2))
def test_duplicate_id(self):
m= Membership()
m.user_prof = self.user2.get_profile()
m.club = self.c
m.num = 1
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today()+datetime.timedelta(days=1)
try:
m.full_clean()
m.save()
except ValidationError as err:
self.assertEqual(str(err),"{'__all__': [u'A member with that number already exists']}")
else:
self.fail("ValidationError expected")
def test_auto_increment_number(self):
m= Membership()
m.user_prof = self.user2.get_profile()
m.club = self.c
m.start = datetime.date.today() - datetime.timedelta(days=300)
m.valid_thru = datetime.date.today()
m.full_clean()
m.save()
self.assertEqual(m.num,2)
def test_is_member(self):
up = self.user1.get_profile()
self.assertTrue(up.is_member(self.c))
def test_coupon_is_valid(self):
user = User()
user.first_name = "justin"
user.last_name = "gray"
user.username = "******"
user.email = "*****@*****.**"
user.save()
user2 = User()
user2.first_name = "sirius"
user2.last_name = "gray"
user2.username = "******"
user2.save()
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()
o = Order()
o.coupon = c
o.user_prof = user.get_profile()
o.save()
self.assertTrue(c.is_valid(user))
c.uses_left = 0
self.assertTrue(c.is_valid(user))
c.expires = datetime.date.today() - datetime.timedelta(days=1)
self.assertTrue(c.is_valid(user))
c.permanent = False
self.assertFalse(c.is_valid(user))
c.expires = datetime.date.today() + datetime.timedelta(days=1)
c.uses_left = 1
self.assertTrue(c.is_valid(user))
c.uses_left = 0
self.assertFalse(c.is_valid(user))
c.uses_left = 1
c.user_prof = user.get_profile()
self.assertFalse(c.is_valid(user2))
c.user_prof = None
c.single_use_per_user = True
self.assertFalse(c.is_valid(user))
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)