def test_create_with_generator(self):
gen = Generator(10, 1000, 10, 150, 10000, verbose=False)
gen.update_prize_pool()
name = 'custom_name'
cps = CashPrizeStructureCreator(generator=gen, name=name)
cps.save()
try:
ps = PrizeStructure.objects.get(name__istartswith=name)
except PrizeStructure.DoesNotExist:
ps = None
self.assertIsNotNone(ps)
def test_h2h_tie(self):
self.first = 1.8
#
# create a simple Rank and Prize Structure
cps = CashPrizeStructureCreator(name='test1')
cps.add(1, self.first)
cps.set_buyin(1.0)
cps.save()
self.prize_structure = cps.prize_structure
self.prize_structure.generator.prize_pool = 1.8 # minus rake
self.prize_structure.save()
self.ranks = cps.ranks
self.contest.status = Contest.SCHEDULED
self.contest.prize_structure = self.prize_structure
self.contest.draft_group = self.draftgroup
self.contest.entries = 2
self.contest.save()
self.create_simple_teams_all_tie(2)
pm = PayoutManager()
pm.payout(finalize_score=False)
payouts = Payout.objects.order_by('contest', '-rank')
for payout in payouts:
self.assertEqual(payout.rank, 1)
trans = CashTransactionDetail.objects.get(
transaction=payout.transaction, user=payout.user)
self.assertAlmostEqual(trans.amount, decimal.Decimal(.90))
def test_calculate_rake_1_dollar_10_entry(self):
from datetime import timedelta
from django.utils import timezone
# create a simple Rank and Prize Structure
cps = CashPrizeStructureCreator(name='test1')
cps.add(1, 4)
cps.add(2, 3)
cps.add(3, 2)
cps.set_buyin(1)
cps.save()
prize_structure = cps.prize_structure
# (10 entries * $10 buyin price - 10% rake fee)
prize_structure.generator.prize_pool = 9
prize_structure.save()
# ranks = cps.ranks
contest = mommy.make(Contest,
entries=10,
prize_structure=prize_structure,
end=timezone.now() + timedelta(hours=1))
# 1 entry -- we took in 1 paid out 4, net -3
self.createUserEntries(contest, 1, 1)
calculate_rake(contest)
self.assertEqual(calculate_rake(contest), -3)
# 2 entries -- we took in 2 and paid out 7, net -5
self.createUserEntries(contest, 1, 1)
calculate_rake(contest)
self.assertEqual(calculate_rake(contest), -5)
# 3 entries -- we took in 3 and paid out 9, net -6
self.createUserEntries(contest, 1, 1)
self.assertEqual(calculate_rake(contest), -6)
# 4 entries -- took in 4, paid out 9, net -5
self.createUserEntries(contest, 1, 1)
self.assertEqual(calculate_rake(contest), -5)
# 8 entries -- took in 8, paid out 9, net -1
self.createUserEntries(contest, 1, 4)
self.assertEqual(calculate_rake(contest), -1)
# full contest, 10 entries -- took in 10, paid out 9, net 1
self.createUserEntries(contest, 1, 2)
self.assertEqual(calculate_rake(contest), 1)
def test_calculate_rake_10_dollar_10_entry(self):
from datetime import timedelta
from django.utils import timezone
# create a simple Rank and Prize Structure
cps = CashPrizeStructureCreator(name='test1')
cps.add(1, 20)
cps.add(2, 10)
cps.add(3, 5)
cps.set_buyin(10)
cps.save()
prize_structure = cps.prize_structure
# (10 entries * $10 buyin price - 10% rake fee)
prize_structure.generator.prize_pool = 90.0
prize_structure.save()
# ranks = cps.ranks
contest = mommy.make(Contest,
entries=10,
prize_structure=prize_structure,
end=timezone.now() + timedelta(hours=1))
# 1 entry -- we took in 10 and paid out 20, net -10
self.createUserEntries(contest, 1, 1)
calculate_rake(contest)
self.assertEqual(calculate_rake(contest), -10)
# 2 entries -- we took in 20 and paid out 30, net -10
self.createUserEntries(contest, 1, 1)
calculate_rake(contest)
self.assertEqual(calculate_rake(contest), -10)
# 3 entries -- we took in 30 and paid out 35, net -5
self.createUserEntries(contest, 1, 1)
self.assertEqual(calculate_rake(contest), -5)
# 4 entries -- took in 40, paid out 35, net 5
self.createUserEntries(contest, 1, 1)
self.assertEqual(calculate_rake(contest), 5)
# 8 entries -- took in 80, paid out 35, net 45
self.createUserEntries(contest, 1, 4)
self.assertEqual(calculate_rake(contest), 45)
# full contest, 10 entries -- took in 100, paid out 35, net 65
self.createUserEntries(contest, 1, 2)
self.assertEqual(calculate_rake(contest), 65)
def createPrizeStructure(buyin=1, first_place=10, round_payouts=10, payout_spots=1,
prize_pool=2):
"""
Create a prize structure. Other than `prize_pool` these numbers really don't matter since
we aren't awarding any prizes in these tests.
:param buyin:
:param first_place:
:param round_payouts:
:param payout_spots:
:param prize_pool: The number of entries allowed in a contest (kinda, in a roundabout way).
:return:
"""
gen = Generator(buyin, first_place, round_payouts, payout_spots, prize_pool, verbose=False)
gen.update_prize_pool()
cps = CashPrizeStructureCreator(generator=gen, name='test_cps')
cps.save()
return cps.prize_structure
def test_create_cash_prize_structure_with_adds(self):
name = 'custom_name'
total_ranks = 2
first = 75.00
second = 25.00
cps = CashPrizeStructureCreator(name=name)
cps.add(1, first)
cps.add(2, second)
cps.set_buyin(5.00)
cps.save()
try:
ps = PrizeStructure.objects.get(name__istartswith=name)
except PrizeStructure.DoesNotExist:
ps = None
self.assertIsNotNone(ps)
ranks = Rank.objects.filter(prize_structure=ps)
self.assertEquals(total_ranks, len(ranks))
def setUp(self):
super().setUp()
# ensure the default ticket
TicketManager.create_default_ticket_amounts(verbose=False)
# add funds to user
self.user = self.get_basic_user()
ct = CashTransaction(self.user)
ct.deposit(100)
# salary_generator = Dummy.generate_salaries()
# self.salary_pool = salary_generator.pool
# start
#
#
self.verbose = True # set to False to disable print statements
#
# The sport we are going to build fake stats for.
# Lets use nfl, but it doesnt matter what sport we use
self.sport = 'nfl'
#
# Ensure there are Games by using the Dummy to generate fake stats.
# The ScheduleManager requires that Game objects exist
# because when it creates scheduled Contest objects
# it is required to create a draft group.
self.dummy = Dummy(sport=self.sport)
self.generator = self.dummy.generate()
self.salary_pool = self.generator.pool
self.site_sport = self.dummy.site_sport # stash the site_sport for easy use
self.site_sport_manager = SiteSportManager()
self.game_model = self.site_sport_manager.get_game_class(
self.site_sport) # ie: sports.nfl.models.Game
self.games = self.game_model.objects.all() # there should be handful now, for today
if self.games.count() <= 0:
raise Exception(
'buyin.tests.BuyinTest - we meant to create games.... but none were created!')
# end
# create a simple prize pool
self.first = 100.0
self.second = 50.0
self.third = 25.0
self.buyin = 10
cps = CashPrizeStructureCreator(name='test')
cps.add(1, self.first)
cps.add(2, self.second)
cps.add(3, self.third)
cps.set_buyin(self.buyin)
cps.save()
cps.prize_structure.save()
self.prize_structure = cps.prize_structure
self.ranks = cps.ranks
#
# create the Contest
# now = timezone.now()
# start = DfsDateTimeUtil.create(now.date(), time(23,0))
# end = DfsDateTimeUtil.create(now.date() + timedelta(days=1), time(0,0))
start = self.games[0].start + timedelta(minutes=5)
end = self.games[self.games.count() - 1].start # set 'end' to start of last game
cc = ContestCreator("test_contest", self.sport, self.prize_structure, start, end)
self.draft_group2 = DraftGroup()
self.draft_group2.salary_pool = self.salary_pool
self.draft_group2.start = start
self.draft_group2.end = end
self.draft_group2.save()
self.contest_pool, created = ContestPoolCreator(
self.sport,
self.prize_structure,
start,
(end - start).seconds * 60,
self.draft_group2
).get_or_create()
self.contest = cc.create()
self.contest.status = Contest.RESERVABLE
self.contest.save()
self.draft_group = DraftGroup()
self.draft_group.salary_pool = self.salary_pool
self.draft_group.start = start
self.draft_group.end = end
self.draft_group.save()
def setUp(self):
super().setUp()
# creates very standard ticket amounts like 1,2,5, 10, 20, 50
TicketManager.create_default_ticket_amounts(verbose=False)
self.first = 34.0
self.second = 10.0
self.third = 10.0
#
# create a simple Rank and Prize Structure
cps = CashPrizeStructureCreator(name='test1')
cps.add(1, self.first)
cps.add(2, self.second)
cps.add(3, self.third)
cps.set_buyin(10)
cps.save()
self.prize_structure = cps.prize_structure
self.prize_structure.generator.prize_pool = 54.0 # minus rake
self.prize_structure.save()
self.ranks = cps.ranks
self.world = BuildWorldForTesting()
self.world.build_world()
self.draftgroup = self.world.draftgroup
self.contest = self.world.contest
self.contest.status = Contest.SCHEDULED
self.contest.prize_structure = self.prize_structure
self.contest.draft_group = self.draftgroup
self.contest.entries = 6
self.contest.save()
self.contest_pool, created = ContestPoolCreator(
'nfl', self.prize_structure, self.draftgroup.start,
(self.draftgroup.end - self.draftgroup.start).seconds * 60,
self.draftgroup).get_or_create()
self.contest_pool.entries = 6
self.contest_pool.save()
self.scorer_class = TestSalaryScoreSystem
def create_prize_structure():
first = 100.0
second = 50.0
third = 25.0
# create a simple Rank and Prize Structure
buyin = 10
cps = CashPrizeStructureCreator(name='test')
cps.add(1, first)
cps.add(2, second)
cps.add(3, third)
cps.set_buyin(buyin)
cps.save()
# cps.prize_structure.buyin = self.buyin
cps.prize_structure.save()
prize_structure = cps.prize_structure
ranks = cps.ranks
return prize_structure
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST)
if form.is_valid():
# <process form cleaned data>
buyin = form.cleaned_data['buyin']
first_place = form.cleaned_data['first_place']
round_payouts = form.cleaned_data['round_payouts']
payout_spots = form.cleaned_data['payout_spots']
prize_pool = form.cleaned_data['prize_pool']
create = form.cleaned_data['create'] # check if this exists ?
print(buyin, first_place, round_payouts, payout_spots, prize_pool,
create)
self.prize_generator = Generator(buyin, first_place, round_payouts,
payout_spots, prize_pool)
context = {'form': form}
##########
##########
prize_list = self.prize_generator.get_prize_list()
range_list = self.prize_generator.get_range_list()
prizes = [x[1] for x in prize_list]
distinct_prizes = [x[0] for x in range_list]
distinct_prize_players = [len(x[1]) for x in range_list]
min_rank_for_prize = [x[1][len(x[1]) - 1] for x in range_list]
context['prizes'] = prizes
context['ranks'] = list(range(1, len(prizes)))
context['ranges'] = self.prize_generator.get_range_list(
) # list( odata.items() )
context['distinctprizes'] = distinct_prizes
context['distinctprizeplayers'] = distinct_prize_players
context['min_rank_for_prize'] = min_rank_for_prize
# some values we might want
context['maxentries'] = self.prize_generator.get_max_entries()
paid = len(prize_list)
context['paid'] = paid
not_paid = int(self.prize_generator.get_max_entries() -
len(prize_list))
context['notpaid'] = not_paid
# generate the data for 1st pie wheel
payoutsdata_list = [
PieDataObj(paid, "#46BFBD", "#5AD3D1", 'Paid').get_data(),
PieDataObj(not_paid, "#F7464A", "#FF5A5E",
'Not Paid').get_data(),
]
context['payoutsdata'] = json.dumps(payoutsdata_list)
# top 10 prizes versus the rest of the prizes
sum_top_10 = 0
sum_11_plus = 0
for i, p in enumerate(prizes):
if i < 10:
sum_top_10 += p
else:
sum_11_plus += p
piedata_list = [
PieDataObj(sum_top_10, "#46BFBD", "#5AD3D1",
"Top 10").get_data(),
PieDataObj(sum_11_plus, "#FDB45C", "#FFC870",
"All Other").get_data(),
]
context['piedata'] = json.dumps(piedata_list)
# context['piedata'] = json.dumps( [
# {
# 'value': 300,
# 'color':"#F7464A",
# 'highlight': "#FF5A5E",
# 'label': "Red"
# },
# {
# 'value': 50,
# 'color': "#46BFBD",
# 'highlight': "#5AD3D1",
# 'label': "Green"
# },
# {
# 'value': 100,
# 'color': "#FDB45C",
# 'highlight': "#FFC870",
# 'label': "Yellow"
# }
# ] )
# top 3 prizes (if there are that many
topprizes_list = [
PieDataObj(prizes[0], "#46BFBD", "#5AD3D1", '1st').get_data(),
]
if len(prizes) >= 2:
topprizes_list.append(
PieDataObj(prizes[1], "#FDB45C", "#FFC870",
'2nd').get_data())
if len(prizes) >= 3:
topprizes_list.append(
PieDataObj(prizes[2], "#F7464A", "#FF5A5E",
'3rd').get_data())
context['topprizes'] = json.dumps(topprizes_list)
# at this point, if 'create' is True, we should
# actually save & commit a new prize structure
if create:
creator = CashPrizeStructureCreator(self.prize_generator,
'generated')
creator.save()
context['created'] = create # we should ACTUALLY create it though.
# return HttpResponseRedirect('/success/')
return render(request, self.template_name, context)
context = {'form': form}
return render(request, self.template_name, context)