def get_player(nick_name='', steam_id=''):
"""
gets player by given params.
If player changed nickname - replaces old one in db
If no such player - creates new
:param nick_name:
:param steam_id:
:param may_be_new:
:return:Player object
"""
print nick_name, steam_id
if nick_name and not steam_id:
try: # FIXME: temporary crutch while checking old players steam_id is impossible (asker required)
return Player.get(nick_name=nick_name)
except:
player = Player.create(steam_id=0, nick_name=nick_name)
return player
elif steam_id and not nick_name:
return Player.get(steam_id=steam_id)
elif steam_id and nick_name:
try:
player = Player.get(steam_id=steam_id)
except:
player = Player.create(steam_id=steam_id, nick_name=nick_name)
if nick_name != player.nick_name:
player.nick_name = nick_name # TODO: test for it
player.save()
return player
def login():
name = request.form.get('name')
email = request.form.get('email')
user = Player.fetch_one(query=['email', '==', email])
secret_number = randint(1, 30)
if not user:
user = Player(name=name, email=email, secret_number=secret_number)
user.create()
response = make_response(redirect(url_for('index')))
response.set_cookie('email', email)
return response
def get_player(update) -> Player:
"""Returns Player model for current user"""
user = update.effective_user
player = session.query(Player).filter_by(user_id=user.id).first()
if player:
sync_player_data(player, user)
else:
player = Player(
user_id=user.id,
username=user.username,
first_name=user.first_name,
last_name=user.last_name,
csgo_nickname=get_nickname(user),
)
player.create()
return player
def join_random(user):
"""Finds and joins the optimal random game."""
if user.num_random > 4:
return jsonify(), 418
game = Game.find_random(user)
if not game:
return jsonify(), 418
player = Player.create(user, game)
player.set_status_joined()
user.num_random += 1
joined = [p for p in game.players
if p.status == Player.JOINED]
if len(joined) == game.max_players:
game.start()
try:
db.session.commit()
except:
db.session.rollback()
raise
return jsonify()
def join_random(user):
"""Finds and joins the optimal random game."""
if user.num_random > 4:
return jsonify(), 418
game = Game.find_random(user)
if not game:
return jsonify(), 418
player = Player.create(user, game)
player.set_status_joined()
user.num_random += 1
joined = [p for p in game.players if p.status == Player.JOINED]
if len(joined) == game.max_players:
game.start()
try:
db.session.commit()
except:
db.session.rollback()
raise
return jsonify()
def initialize_player_position(args):
player_id = get_player_id(args)
start_position = get_pos_by_name(args.location)
if len(Player.select().where(Player.player_id == player_id)) == 0:
Player.create(
player_id=player_id,
name=args.username,
enabled=True,
last_modified=datetime.now(),
start_latitude=start_position[0],
start_longitude=start_position[1]
)
else:
Player.update(
last_modified=datetime.now(),
start_latitude=start_position[0],
start_longitude=start_position[1]
).where(Player.player_id == player_id).execute()
def sign_up(self, message):
if self.is_bot(message['user']):
self.talk('Nice try, <@' + message['user'] + '>: ' + 'No bots allowed!')
return
try:
player = Player.create(slack_id=message['user'])
self.talk('<@' + message['user'] + '>: ' + 'You\'re all signed up. Good luck!')
except IntegrityError:
self.talk('<@' + message['user'] + '>: ' + 'You\'re already signed up!')
def sign_up(self, message):
if self.is_bot(message['user']):
self.talk('Nice try, <@' + message['user'] + '>: ' + 'No bots allowed!')
return
try:
player = Player.create(slack_id=message['user'])
self.talk('<@' + message['user'] + '>: ' + 'You\'re all signed up. Good luck!')
except IntegrityError:
self.talk('<@' + message['user'] + '>: ' + 'You\'re already signed up!')
def create_room():
"""
Route creates new room and redirects to the lobby.
It adds a new player to the room and sets session cookie if not present
"""
username = request.forms.get("username")
if len(username) == 0:
return HTTPError(403, "Username too short")
sessid = request.cookies.get("sessid", generate_sessid())
room = Room.create(code=generate_room_code())
player = Player.create(sessid=sessid, name=username, room=room)
room.owner = player
room.save()
response.set_cookie("sessid", sessid, path="/")
return redirect("/game/%s/lobby" % room.code)
def register():
group_name = request.form['group'].strip()
player_name = request.form['player'].strip()
try:
# Perform case-insensitive search.
group = Group.get(fn.Lower(Group.name) == group_name.lower())
except:
group = Group.create(name=group_name)
try:
# Perform case-insensitive search.
player = Player.get(fn.lower(Player.name) == player_name.lower(), group=group)
except Player.DoesNotExist:
player = Player.create(
group=group, name=player_name, order=group.players.count())
return str(player.id)
def register():
group_name = request.form['group'].strip()
player_name = request.form['player'].strip()
try:
# Perform case-insensitive search.
group = Group.get(fn.Lower(Group.name) == group_name.lower())
except:
group = Group.create(name=group_name)
try:
# Perform case-insensitive search.
player = Player.get(fn.lower(Player.name) == player_name.lower(),
group=group)
except Player.DoesNotExist:
player = Player.create(group=group,
name=player_name,
order=group.players.count())
return str(player.id)
def add_player():
name = request.form.get('name')
surname = request.form.get('surname')
Player.create({'name': name, 'surname': surname})
return redirect(url_for('index'))
def get_user(content):
"""
Find and return the user's info, or
create the user if he doesn't exist.
If the user doesn't exist, enter
the user into 3 random games and
add 5 random friends.
"""
token = content['token']
device = content['device']
now = datetime.now()
user = User.auth(token)
if not user:
user = User.create(token)
if not user:
return jsonify(), 418
else: # give the new user 3 random games and 5 random friends
games = Game.find_n_random(3, user)
players = [Player.create(user, game) for game in games]
[player.set_status_joined() for player in players]
for game in games:
joined = [p for p in game.players
if p.status == Player.JOINED]
if len(joined) == game.max_players:
game.start()
friends = User.find_n_random(5, user)
[f.add(user) for f in friends]
[user.add(f) for f in friends]
user.device = device
try:
db.session.commit()
except:
db.session.rollback()
raise
friendships = user.get_friendships()
friends = []
for friendship in friendships:
friend = \
friendship.sender if friendship.sender != user else \
friendship.receiver
friend_json = {
'name' : friend.name,
'email' : friend.email,
'picture': friend.picture
}
if friendship.valid:
friend_json['status'] = Friendship.VALID
elif friend == friendship.sender:
friend_json['status'] = Friendship.REQUEST
else:
friend_json['status'] = Friendship.PENDING
friends.append(friend_json)
return jsonify(**{
'name' : user.name,
'email' : user.email,
'picture': user.picture,
'token' : user.token,
'friends': friends,
'games' : [
{
'id' : p.game.id,
'name' : p.game.name,
'status' : p.game.status,
'player_status': p.status,
'seen' : p.seen,
'random' : p.game.random,
'players' : [
{
'name' : _p.user.name,
'email' : _p.user.email,
'picture': _p.user.picture,
'status' : _p.status,
'points' : _p.score
}
for _p in p.game.players
]
}
for p in user.players
if not p.game.end_time or p.game.end_time + timedelta(weeks=1) > now
]
})
def test_find(self):
Player.create({"name": "test", "surname": "test"})
players = Player.find()
self.assertGreater(len(players), 0, "Players array should be greater than zero")
