def create_parimutuel():
wager = Parimutuel(
value=generate_random_int(),
currency=generate_random_currency(),
transaction_date=generate_random_date(include_time=True),
count=generate_random_int(length=1))
return wager
def create_casino():
wager = Casino(value=generate_random_int(),
currency="EUR",
transaction_date=generate_random_date(),
game_type="Video slot",
game_identifier=generate_random_int(),
count=4)
return wager
def create_sport():
wager = Sport(sport="Football",
league="Serie A",
event="AC Milan vs Juventus FC",
live=True,
event_id=generate_random_int(),
currency="EUR",
value=generate_random_int(),
transaction_date=generate_random_date(),
count=1)
return wager
def create_esport():
wager = Esport(game="CS Zero",
league="League 1",
event_id=generate_random_int(),
event_category="Day 2",
event_date=generate_random_date(),
event="Mark Brown vs Matt White",
currency="EUR",
value=generate_random_int(),
transaction_date=generate_random_date(),
count=1)
return wager
def create_random_player(player_id_length=5):
player = Player(player_id=generate_random_int(length=player_id_length),
name=generate_random_string(),
email="{}@test.com".format(generate_random_string()),
surname=generate_random_string(),
country_code=generate_random_country_code(),
city=generate_random_string(),
zip_code=generate_random_int(),
state=generate_random_state(),
mobile_phone=generate_random_int(14),
signup_date=generate_random_date(include_time=True),
date_of_bith=generate_random_date(),
custom_int_1=generate_random_int(1),
custom_int_2=generate_random_int(2),
custom_int_3=generate_random_int(1),
custom_int_4=generate_random_int(2),
custom_string=generate_random_string(),
custom_string_2=generate_random_string(),
custom_string_3=generate_random_string(),
custom_string_4=0,
time_zone=generate_random_int(2),
language_code=generate_random_language_code(),
btag=generate_random_string(),
promo_code=generate_random_string(),
tracking_code=generate_random_string(),
optout_email=generate_random_boolean(),
optout_sms=generate_random_boolean(),
optout_push=generate_random_boolean(),
optout_mobile_push=generate_random_boolean())
return player
def create_deposit(self):
transactions = [create_revenue() for i in range(100)]
data = {"PlayerID": self.player.PlayerID, "InitID": generate_random_int(),
"Transactions": [r.__dict__ for r in transactions]}
self.client.post(get_deposit_resource(),
data=json.dumps(data),
headers=get_api_headers())
def create_bonus():
bonus = Bonus(value=generate_random_int(),
currency="EUR",
transaction_date=generate_random_date(),
identifier="Deposit bonus 50% max 2K x50 wagers",
product_id=generate_random_productid())
return bonus
def create_five_wagers(self):
wagers, url = self.create_random_wager()
data = {
"PlayerID": self.player.PlayerID,
"InitID": generate_random_int(),
"Wagers": [r.__dict__ for r in wagers]
}
self.client.post(url, data=json.dumps(data), headers=get_api_headers())
def create_revenue():
revenue = Revenue(
amount=generate_random_int(),
currency="EUR",
transaction_date=generate_random_date(),
success=True,
payment_method="Skrill")
return revenue
def create_payout(payout_type, **kwargs):
payout = Payout(amount=float(generate_random_int(3)),
product_id=game_ids[payout_type],
currency="EUR",
transaction_date=generate_random_date(include_time=True),
game=None if game_types[payout_type] is None else
game_types[payout_type]().__dict__,
count=4)
return payout
def create_lottery():
wager = Lottery(name="Euro millions",
category="EU based lottery",
draw_date=generate_random_date(),
currency="EUR",
value=generate_random_int(),
transaction_date=generate_random_date(),
count=1)
return wager
def create_bet():
wager = Bet(event_category="Weather",
event_date=generate_random_date(),
event="Rainy",
currency="EUR",
value=generate_random_int(),
transaction_date=generate_random_date(),
count=1)
return wager
def create_wager_casino(self):
wagers = [create_wager_casino() for i in range(100)]
data = {
"PlayerID": self.player.PlayerID,
"InitID": generate_random_int(),
"Wagers": [r.__dict__ for r in wagers]
}
self.client.post(get_wager_casino_resource(channel=1),
data=json.dumps(data),
headers=get_api_headers())
def create_payout(self):
bonuses = [create_payout(self.get_payout_type())]
data = {
"PlayerID": self.player.PlayerID,
"InitID": generate_random_int(),
"Payouts": [r.__dict__ for r in bonuses]
}
self.client.post(get_payout_resource(),
data=json.dumps(data),
headers=get_api_headers())
def create_withdrawal(self):
withdrawals = [create_withdrawal()]
data = {
"PlayerID": self.player.PlayerID,
"InitID": generate_random_int(),
"Withdrawals": [r.__dict__ for r in withdrawals]
}
self.client.post(get_withdrawal_resource(),
data=json.dumps(data),
headers=get_api_headers())
def _create_wagers(player, wagers=[]):
_wagers = [create_casino()] if wagers == [] else wagers
logging.info("Creating wagers: {}".format([r.__dict__ for r in _wagers]))
data = {"PlayerID": player.PlayerID, "InitID": generate_random_int(),
"Wagers": [r.__dict__ for r in _wagers]}
logging.info("Request data: {}".format(json.dumps(data)))
response = requests.post(get_wager_casino_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return wagers, response.json()["RequestID"]
def _create_bonuses(player, bonuses=[]):
_bonuses = [create_bonus()] if bonuses == [] else bonuses
logging.info("Creating bonus: {}".format(
[r.__dict__ for r in _bonuses]))
data = {
"PlayerID": player.PlayerID,
"InitID": generate_random_int(),
"Bonuses": [r.__dict__ for r in _bonuses]
}
logging.info("Request data: {}".format(json.dumps(data)))
response = requests.post(get_bonus_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return bonuses, response.json()["RequestID"]
def _create_revenues(player, revenues=[]):
revenues = [create_revenue()] if revenues == [] else revenues
logging.info("Creating revenue: {}".format(
[r.__dict__ for r in revenues]))
data = {
"PlayerID": player.PlayerID,
"InitID": generate_random_int(),
"Transactions": [r.__dict__ for r in revenues]
}
logging.info("Request data: {}".format(json.dumps(data)))
response = requests.post(get_deposit_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return revenues, response.json()["RequestID"]
def _create_payouts(player, payout_type, payouts=[]):
_payouts = [create_payout(
payout_type=payout_type)] if payouts == [] else payouts
logging.info("Creating payouts: {}".format(
[r.__dict__ for r in _payouts]))
data = {
"PlayerID": player.PlayerID,
"InitID": int(generate_random_int()),
"Payouts": [r.__dict__ for r in _payouts]
}
logging.info("Request data: {}".format(json.dumps(data)))
response = requests.post(get_payout_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return payouts, response.json()["RequestID"]
def _create_player_with_withdrawal(withdrawal=None):
player = create_random_player(player_id_length=40)
logging.info("Creating player: {}".format(player.__dict__))
response = requests.post(get_player_sign_up_resource(),
data=json.dumps(player.__dict__),
headers=get_api_headers())
body = response.json()
logging.info("API response: {}".format(body))
withdrawal = create_withdrawal() if withdrawal is None else withdrawal
logging.info("Creating withdrawal: {}".format(withdrawal.__dict__))
data = {
"PlayerID": player.PlayerID,
"InitID": generate_random_int(),
"Withdrawals": [withdrawal.__dict__]
}
logging.info("Request data: {}".format(data))
response = requests.post(get_withdrawal_resource(),
data=json.dumps(data),
headers=get_api_headers())
logging.info("API response: {}".format(response.json()))
return player, withdrawal, response.json()["RequestID"]
def create_freespin(is_future=False):
freespin = Freespin(value=generate_random_int(),
transaction_date=generate_random_date(
include_time=True, is_future=is_future),
identifier=generate_random_string(100))
return freespin
def create_withdrawal():
withdrawal = Withdrawal(amount=generate_random_int(3),
currency="USD",
transaction_date=generate_random_date())
return withdrawal
