def add_initial_player(session):
initial_player = session.query(
Player.platformid == default_player_id()).first()
if initial_player is not None:
return
session.add(Player(platformid=default_player_id()))
session.commit()
def setUp(self):
self.tag_name_alt = TAGS[1]
self.all_tags = TAGS
self.test_user_id = TEST_USER_ID
engine, Session = startup()
self.session = Session()
self.test_game_id = TEST_GAME_ID
self.test_game_ids = self.create_replay_names()
test_user = self.session.query(Player).filter(Player.platformid == self.test_user_id).first()
if test_user is None:
test_user = Player(platformid=self.test_user_id)
self.session.add(test_user)
for i in range(len(self.test_game_ids)):
tag_name = self.all_tags[i]
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == tag_name).first()
if tag is None:
tag = Tag(owner=self.test_user_id, name=tag_name)
self.session.add(tag)
for game_id in self.test_game_ids:
game = self.session.query(Game).filter(Game.hash == game_id).first()
if game is None:
game = Game(hash=game_id)
self.session.add(game)
self.session.commit()
# add some spice to the games :>
for i in range(len(self.test_game_ids)):
game_id = self.test_game_ids[i]
for j in range(len(self.test_game_ids) - i):
TagWrapper.add_tag_to_game(self.session, game_id, self.test_user_id, self.all_tags[j])
def test_upload_files(self, mock_user, no_errors_are_logged):
no_errors_are_logged.cancel_check()
mock_user.set_fake_user(
Player(platformid='76561198018756583', platformname='fake'))
replay_list = get_complex_replay_list()[0:4]
tags = ['TAG1', 'TAG2', 'TAG3', ['TAG4', 'TAG2']]
privacy = [
GameVisibilitySetting.DEFAULT.name,
GameVisibilitySetting.PUBLIC.name,
GameVisibilitySetting.PRIVATE.name,
GameVisibilitySetting.PRIVATE.name
]
users = [
'invalid', '76561198018756583', '76561198018756583',
'76561198018756583'
]
for index, replay_url in enumerate(replay_list):
params = {
'tags': tags[index],
'visibility': privacy[index],
'player_id': users[index]
}
logger.debug('Testing:', replay_url)
f = download_replay_discord(replay_url)
r = requests.post(LOCAL_URL + '/api/upload',
files={'replays': ('fake_file.replay', f)},
params=params)
r.raise_for_status()
assert (r.status_code == 202)
for i in range(len(replay_list) + 1):
logger.debug('waiting ', (len(replay_list) - i) * sleep_time,
'seconds')
time.sleep(sleep_time)
time.sleep(sleep_time)
r = requests.get(LOCAL_URL + '/api/global/replay_count')
result = json.loads(r.content)
assert (int(result) == len(replay_list))
response = requests.get(LOCAL_URL + '/api/tag')
result = json.loads(response.content)
assert result[0]['owner_id'] == "76561198018756583"
assert result[0]['name'].startswith('TAG')
assert len(result) == 3
response = requests.get(
LOCAL_URL +
'/api/player/76561198018756583/match_history?page=0&limit=10')
assert response.status_code == 200
assert len(response.json()['replays']) >= 1
def add_or_update_steam_player(profile, session=None):
match = session.query(Player).filter(Player.platformid == profile['steamid']).first()
if match:
match.platformname = profile['personaname']
match.avatar = profile['avatarfull']
else:
u = Player(platformid=profile['steamid'], platformname=profile['personaname'], avatar=profile['avatarfull'],
groups=[])
session.add(u)
session.commit()
def setUp(self):
self.tag_name = TAGS[0]
self.test_user_id = TEST_USER_ID
engine, Session = startup()
self.session = Session()
test_user = self.session.query(Player).filter(Player.platformid == self.test_user_id).first()
if test_user is None:
test_user = Player(platformid=self.test_user_id)
self.session.add(test_user)
self.session.commit()
def create_default_player():
player = Player()
player.platformid = "3678"
player.platformname = 'test user with a really long name but even longer'
if bool(random.getrandbits(1)):
player.avatar = "https://media.istockphoto.com/photos/golden-retriever-puppy-looking-up-isolated-on-black-backround-picture-id466614709?k=6&m=466614709&s=612x612&w=0&h=AVW-4RuYXFPXxLBMHiqoAKnvLrMGT9g62SduH2eNHxA="
else:
player.avatar = "https://cdn3-www.dogtime.com/assets/uploads/2014/12/file_19035_square_100_rainy-day-activity-dog-playing-with-food-toy.jpg"
return player
def steam_process():
if validate_openid(request.args):
user_id = request.args['openid.claimed_id'].split('/')[-1]
profile = get_steam_profile_or_random_response(user_id)['response']['players'][0]
s = current_app.config['db']()
match = s.query(Player).filter(Player.platformid == user_id).first()
if match:
match.platformname = profile['personaname']
match.avatar = profile['avatarfull']
else:
u = Player(platformid=user_id, platformname=profile['personaname'], avatar=profile['avatarfull'], groups=[])
s.add(u)
s.commit()
s.close()
session['openid'] = user_id
return redirect(url_for('home'))
return jsonify({'error': 'invalid openid credentials'})
def addrole(id, role, session=None):
"""Adds a role to a person given an ID and a role id.
:param id: platformid of the person to add the role to
:param role: the id of the role
:return: redirect to the previous url
"""
role_id = session.query(Group).filter(Group.name == role).first().id
print(role, role_id)
player = session.query(Player).filter(Player.platformid == id).first()
if player is None:
p = Player(platformid=id,
platformname='',
avatar='',
ranks='',
groups=[role_id])
session.add(p)
else:
if role_id not in player.groups:
player.groups = player.groups + [role_id]
session.commit()
return redirect(redirect_url())
def steam_process(session=None):
if validate_openid(request.args):
user_id = request.args['openid.claimed_id'].split('/')[-1]
profile = get_steam_profile_or_random_response(
user_id)['response']['players'][0]
add_or_update_steam_player(profile)
match = session.query(Player).filter(
Player.platformid == user_id).first()
if match:
match.platformname = profile['personaname']
match.avatar = profile['avatarfull']
else:
u = Player(platformid=user_id,
platformname=profile['personaname'],
avatar=profile['avatarfull'],
groups=[])
session.add(u)
session.commit()
flask_session['openid'] = user_id
flask_session.permanent = True
return redirect(url_for('home'))
return jsonify({'error': 'invalid openid credentials'})
def setUp(self):
self.tag_name = TAGS[0]
self.tag_name_alt = TAGS[1]
self.test_user_id = TEST_USER_ID
engine, Session = startup()
self.session = Session()
self.test_game_id = TEST_GAME_ID
test_user = self.session.query(Player).filter(Player.platformid == self.test_user_id).first()
if test_user is None:
test_user = Player(platformid=self.test_user_id)
self.session.add(test_user)
tag = self.session.query(Tag).filter(Tag.owner == self.test_user_id, Tag.name == self.tag_name).first()
if tag is None:
tag = Tag(owner=self.test_user_id, name=self.tag_name)
self.session.add(tag)
game = self.session.query(Game).filter(Game.hash == self.test_game_id).first()
if game is None:
game = Game(hash=self.test_game_id)
self.session.add(game)
self.session.commit()
def convert_pickle_to_db(
game: game_pb2,
offline_redis=None) -> (Game, list, list, List[Loadout]):
"""
Converts pickled games into various database objects.
:param game: Pickled game to process into Database object
:return: Game db object, PlayerGame array, Player array
"""
teamsize = max(len(game.teams[0].player_ids),
len(game.teams[1].player_ids))
player_objs = game.players
ranks = get_rank_batch([p.id.id for p in player_objs],
offline_redis=offline_redis)
rank_list = []
mmr_list = []
for player, rank in ranks.items():
r = get_rank_obj_by_mapping(rank, playlist=game.game_metadata.playlist)
rank_list.append(r['tier'])
mmr_list.append(r['rank_points'])
replay_id = game.game_metadata.match_guid
if replay_id == '' or replay_id is None:
replay_id = game.game_metadata.id
team0poss = game.teams[0].stats.possession
team1poss = game.teams[1].stats.possession
match_date = datetime.datetime.fromtimestamp(game.game_metadata.time)
match_name = game.game_metadata.name
g = Game(hash=replay_id,
players=[str(p.id.id) for p in player_objs],
ranks=rank_list,
mmrs=mmr_list,
map=game.game_metadata.map,
team0score=game.game_metadata.score.team_0_score,
team1score=game.game_metadata.score.team_1_score,
teamsize=teamsize,
match_date=match_date,
team0possession=team0poss.possession_time,
team1possession=team1poss.possession_time,
name='' if match_name is None else match_name,
frames=game.game_metadata.frames,
length=game.game_metadata.length,
playlist=game.game_metadata.playlist,
game_server_id=0 if game.game_metadata.game_server_id == '' else
game.game_metadata.game_server_id,
server_name=game.game_metadata.server_name,
replay_id=game.game_metadata.id,
primary_player=game.game_metadata.primary_player.id)
player_games = []
players = []
teamstats = []
# print('iterating over players')
for team in game.teams:
fields = create_and_filter_proto_field(team,
['id', 'name', 'is_orange'], [],
TeamStat)
values = get_proto_values(team, fields)
kwargs = {k.field_name: v for k, v in zip(fields, values)}
for k in kwargs:
if kwargs[k] == 'NaN' or math.isnan(kwargs[k]):
kwargs[k] = 0.0
t = TeamStat(game=replay_id, is_orange=team.is_orange, **kwargs)
teamstats.append(t)
for p in player_objs: # type: GamePlayer
fields = create_and_filter_proto_field(
p, ['name', 'title_id', 'is_orange'], [
'api.metadata.CameraSettings', 'api.metadata.PlayerLoadout',
'api.PlayerId'
], PlayerGame)
values = get_proto_values(p, fields)
kwargs = {k.field_name: v for k, v in zip(fields, values)}
for k in kwargs:
if kwargs[k] == 'NaN' or math.isnan(kwargs[k]):
kwargs[k] = 0.0
camera = p.camera_settings
loadout = p.loadout
field_of_view = camera.field_of_view
transition_speed = camera.transition_speed
pitch = camera.pitch
swivel_speed = camera.swivel_speed
stiffness = camera.stiffness
height = camera.height
distance = camera.distance
blue_score = game.game_metadata.score.team_0_score
orange_score = game.game_metadata.score.team_1_score
is_orange = p.is_orange
pid = str(p.id.id)
rank = None
mmr = None
division = None
if pid in ranks:
try:
r = get_rank_obj_by_mapping(
ranks[pid], playlist=game.game_metadata.playlist)
rank = r['tier']
division = r['division']
mmr = r['rank_points']
except:
rank = 0
division = 0
mmr = 0
if is_orange:
win = orange_score > blue_score
else:
win = blue_score > orange_score
pg = PlayerGame(player=pid,
name=p.name,
game=replay_id,
field_of_view=field_of_view,
transition_speed=transition_speed,
pitch=pitch,
swivel_speed=swivel_speed,
stiffness=stiffness,
height=height,
distance=distance,
car=-1 if loadout is None else loadout.car,
is_orange=p.is_orange,
rank=rank,
division=division,
mmr=mmr,
win=win,
**kwargs)
player_games.append(pg)
if len(str(pid)) > 40:
pid = pid[:40]
p = Player(platformid=pid,
platformname=p.name,
avatar="",
ranks=[],
groups=[])
players.append(p)
loadouts = process_loadout_to_obj(game)
return g, player_games, players, teamstats, loadouts
def __init__(self):
self.user = Player(platformid=default_player_id(), platformname="default")
def setUser(self, platformId):
nonlocal fake_user
fake_user = Player(platformid=platformId)
def test_upload_files(self, mock_user, no_errors_are_logged):
no_errors_are_logged.cancel_check()
mock_user.set_user(
Player(platformid='76561198018756583', platformname='fake'))
replay_list = get_complex_replay_list()[0:4]
tags = [['TAG1'], ['TAG2'], ['TAG3'], ['TAG4', 'TAG2']]
privacy = [
GameVisibilitySetting.DEFAULT.name,
GameVisibilitySetting.PUBLIC.name,
GameVisibilitySetting.PRIVATE.name,
GameVisibilitySetting.PRIVATE.name
]
users = [
'76561198018756583', 'invalid', '76561198018756583',
'76561198018756583'
]
tag_keys = ['invalid_key']
def create_all_tags():
created_tags = []
for _tags in tags:
keys = []
for _tag in _tags:
if _tag not in created_tags:
r = requests.put(LOCAL_URL + f'/api/tag/{_tag}')
r.raise_for_status()
created_tags.append(_tag)
# create private id
r = requests.put(LOCAL_URL +
f'/api/tag/{_tag}/private_key/{_tag}')
r.raise_for_status()
json = requests.get(LOCAL_URL +
f'/api/tag/{_tag}/private_key').json()
keys.append(json)
tag_keys.append(keys)
for index, replay_url in enumerate(replay_list):
if index == 1:
logger.error("CREATING INITIAL TAG DATA")
time.sleep(20)
create_all_tags()
time.sleep(1)
params = {
'visibility': privacy[index],
'player_id': users[index],
'private_tag_keys': tag_keys[index]
}
logger.debug('TESTING URL:' + str(replay_url))
logger.debug('TESTING PARAMS:' + str(params))
f = download_replay_discord(replay_url)
r = requests.post(LOCAL_URL + '/api/upload',
files={'replays': ('fake_file.replay', f)},
params=params)
r.raise_for_status()
assert (r.status_code == 202)
for i in range(len(replay_list) + 1):
logger.debug('waiting ', (len(replay_list) - i) * sleep_time,
'seconds')
time.sleep(sleep_time)
time.sleep(sleep_time)
r = requests.get(LOCAL_URL + '/api/global/replay_count')
result = json.loads(r.content)
assert (int(result) == len(replay_list))
response = requests.get(LOCAL_URL + '/api/tag')
result = json.loads(response.content)
assert result[0]['ownerId'] == "76561198018756583"
assert result[0]['name'].startswith('TAG')
assert len(result) == 4
response = requests.get(
LOCAL_URL +
'/api/player/76561198018756583/match_history?page=0&limit=10')
assert response.status_code == 200
assert len(response.json()['replays']) >= 1
def set_user_id(self, user_id: str):
self.user = Player(platformid=user_id)
def __init__(self):
self.logged_out = False
self.user = Player(platformid=default_player_id(),
platformname="default")
