def test_list(self):
u1 = User(username='******', email='*****@*****.**', password='******')
u2 = User(username='******', email='*****@*****.**', password='******')
u3 = User(username='******', email='*****@*****.**', password='******')
u4 = User(username='******', email='*****@*****.**', password='******')
g1 = Game(author=u1, guest=u2, max_points=1, status='author_win')
g2 = Game(author=u1,
guest=u3,
max_points=1,
status='author_turn_to_ask')
g3 = Game(author=u4, guest=u1, max_points=1, status='not_confirmed')
db.session.add_all([u1, u2, u3, u4, g1, g2, g3])
db.session.commit()
with self.client:
self.client.post(url_for('auth.login'),
data={
'email': '*****@*****.**',
'password': '******'
})
response = self.client.get(url_for('games.list'))
data = response.get_data(as_text=True)
self.assertEqual(response.status_code, 200)
self.assertTrue('one VS. two' in data)
self.assertTrue('one VS. three' in data)
self.assertTrue('four VS. one' in data)
def games():
form = GameForm()
search = SearchForm()
games = Game.query.all()
now = datetime.now()
print(form.date.data)
if form.validate_on_submit():
dateOut = form.date.data
#if the date the user enters is earlier than the current date
#then dont let them enter it
if now > dateOut:
flash("ERROR: Invalid Date")
return redirect(url_for('games'))
#if the amount of money the user wants to bet is more than they have
#then dont let them and reload the page
#if not, then make a new game with all of the paramiters
#given by the feild
if form.initalBetA.data > 0:
current_user.minus_moola(form.initalBetA.data)
if current_user.moola < 0:
current_user.add_moola(form.initalBetA.data)
flash("ERROR: Insuficent Funds")
return redirect(url_for('games'))
game = Game(userId=current_user.id, sport=form.sport.data, location=form.location.data, watchSpot=form.watchSpot.data, eventName=form.name.data, openingBetA=form.initalBetA.data, currentBetA=form.initalBetA.data, openingBetB=0, currentBetB=0, teamA= form.teamA.data , teamB= form.teamB.data, closeDate=dateOut )
elif form.initalBetB.data > 0:
current_user.minus_moola(form.initalBetB.data)
if current_user.moola < 0:
current_user.add_moola(form.initalBetB.data)
flash("ERROR: Insuficent Funds")
return redirect(url_for('games'))
game = Game(userId=current_user.id, sport=form.sport.data, location=form.location.data, watchSpot=form.watchSpot.data, eventName=form.name.data, openingBetA=0, currentBetA=0, openingBetB=form.initalBetB.data, currentBetB=form.initalBetB.data, teamA= form.teamA.data , teamB= form.teamB.data, closeDate=dateOut )
#if user didnt enter a starting bet for either team
#then set both to zero
else:
game = Game(userId=current_user.id, sport=form.sport.data, location=form.location.data, watchSpot=form.watchSpot.data, eventName=form.name.data, openingBetA=0, currentBetA=0, openingBetB=0, currentBetB=0, teamA= form.teamA.data , teamB= form.teamB.data, closeDate=dateOut )
#add the game to database
db.session.add(game)
db.session.commit()
flash('Congratulations, you added a game!')
return redirect(url_for('games'))
#If someone searches for something in the search bar
#Then reload the page with a new list of games using the paramiters given
elif search.validate_on_submit():
games = Game.query.filter_by(sport=search.sport.data).all()
return render_template("games.html", title='Home Page', games=games, form=form, now=now, search=search)
#Getting the current time of day to make sure the user
#doesn't enter a date for a game that has already pased
now = datetime.now()
return render_template("games.html", title='Home Page', games=games, form=form, now=now, search=search)
def get_game() -> Game:
game = Game.query.filter(Game.state == GameState.OPEN).first()
if not game:
game = Game(id=str(uuid.uuid4()), state=GameState.OPEN)
game.save()
return game
if len(game.players.all()) > GameService.MAX_PLAYER:
game.state = GameState.IN_PROGRESS
game.save()
game = Game(id=str(uuid.uuid4()), state=GameState.OPEN)
return game
def game_api_post():
current_app.logger.debug(f'creating game')
if current_user.is_anonymous:
game = Game()
else:
game = Game(player=current_user)
db.session.add(game)
db.session.commit()
return jsonify(game.to_dict())
def add_game(session, winner_id, loser_id, submitted_by_id):
if winner_id == loser_id:
raise Exception("can't play yourself")
winner = session.query(User).get(winner_id)
loser = session.query(User).get(loser_id)
submitted_by = session.query(User).get(submitted_by_id)
winner_rating, loser_rating = trueskill.rate_1vs1(
trueskill.Rating(winner.elo), trueskill.Rating(loser.elo))
winner_elo, loser_elo = winner_rating.mu, loser_rating.mu
# verify created at
new_game = Game(
winner=winner,
loser=loser,
submitted_by=submitted_by,
winner_elo_score=winner_elo,
loser_elo_score=loser_elo,
)
winner.elo = winner_elo
loser.elo = loser_elo
winner.wins = winner.wins + 1
loser.losses = loser.losses + 1
session.add_all([new_game, winner, loser])
return new_game
def test_create_frame_db(self):
game = Game(players=['player1', 'player2', 'player3'])
db.session.add(game)
frame = Frame(game.players[0], 1)
db.session.commit()
assert frame.id
assert frame.frame_number
def index():
if request.method == 'POST':
nickname = request.form.get('nickname')
password = request.form.get('password')
if password == '':
password = None
if nickname == '':
background = random.choice(['1', '2', '3'])
return render_template('index.html', background=url_for('static', filename='backgrounds/{}.jpg'.format(background)), errors=True)
g = Game(password=password, card=BlackCards.query.order_by(func.random()).first())
db.session.add(g)
db.session.commit()
p = Player(nickname=nickname, game=g, uuid=uuid.uuid4().hex)
db.session.add(p)
db.session.commit()
session['player'] = p.id
return redirect( url_for('game', id=g.id) )
elif request.method == 'GET':
background = random.choice(['1', '2', '3'])
return render_template('index.html', background=url_for('static', filename='backgrounds/{}.jpg'.format(background)))
def postGame():
try:
title = request.headers.get("title")
descriptionURL = request.headers.get("descriptionURL")
imageURL = request.headers.get("imageURL")
rating = request.headers.get("rating")
price = request.headers.get("price")
type = request.headers.get("type")
genre = request.headers.get("genre")
quantity = request.headers.get("quantity")
game = Game(title=title,
descriptionURL=descriptionURL,
imageURL=imageURL,
rating=rating,
price=price,
type=type,
genre=genre,
quantity=quantity)
db.session.add(game)
db.session.commit()
return jsonify({"Success": f'{title} added'})
except:
return jsonify({"error#1337": "Game could not be saved"})
def creategame():
form = CreateGameForm()
# ************ After submission *************
if form.validate_on_submit():
if current_user.state == "joining":
flash(f'You are already joining a game. please wait for game to finish initializing','warning')
return render_template("title.html")
else:
current_user.state = "joining"
# Check to see if user has 5 companies currently playing the game. Don't count games that are finished.
# This needs to be fixed to not include finished games in the query.
num_playing_companies = Company.query.filter(Company.id_user == current_user.id).count()
if num_playing_companies < current_user.companies_max:
game = Game(name=form.gamename.data)
db.session.add(game)
db.session.commit()
return redirect(url_for('game.initgame', gid=game.id, name=form.companyname.data))
else:
flash(f'You are already playing too many concurrent games. Try rejoining one in progress','danger')
return render_template("title.html")
return render_template("creategame.html", form=form)
def play(self, fake, current_round, teams):
for r in range(0, len(teams), 2):
if r + 1 < len(teams):
host = teams[r]
guest = teams[r + 1]
self.stdout.write(
self.style.SUCCESS('%s : Creating game between %s and %s' % (current_round, host, guest)))
# temporally set host as winner
game = Game(host=host, guest=guest, round=current_round, winner=host,
date=fake.date_time_this_decade(before_now=True, after_now=False, tzinfo=None))
game.save()
host_score = players_scoring(self, fake, host, game)
host_team_stat = TeamStat(game=game, team=host, score=host_score)
host_team_stat.save()
guest_score = players_scoring(self, fake, guest, game)
guest_team_stat = TeamStat(game=game, team=guest, score=guest_score)
guest_team_stat.save()
# not handled the tie scenario
if guest_score > host_score:
game.winner = guest
else:
game.winner = host
game.save()
self.stdout.write(self.style.SUCCESS('%s scored %s' % (game.host.name, host_score)))
self.stdout.write(self.style.SUCCESS('%s scored %s' % (game.guest.name, guest_score)))
self.stdout.write(self.style.SUCCESS('%s won the game' % game.winner))
self.stdout.write('\n')
def save_answer():
if request.method == 'POST':
try:
posted_data = request.form.to_dict()
board = posted_data['boggle_board']
found_list = ','.join(request.form.getlist('found_list[]'))
words_list = ','.join(request.form.getlist('words_list[]'))
score = posted_data['score']
gh = Game(user_id=current_user.id,
board=board,
found=found_list,
result=words_list,
score=score)
db.session.add(gh)
db.session.commit()
message = "Score saved."
response = app.response_class(response=json.dumps(message),
status=200,
mimetype='application/json')
except:
message = "Some error occurred. Sorry for the inconvineince"
response = app.response_class(response=json.dumps(data),
status=400,
mimetype='application/json')
return response
def test_list(self):
u1 = User(username='******', email='*****@*****.**', password='******')
u2 = User(username='******', email='*****@*****.**', password='******')
u3 = User(username='******', email='*****@*****.**', password='******')
q1 = Question(answer='q1')
q2 = Question(answer='q2')
g1 = Game()
q1.author = u2
q2.author = u3
q1.recipient = u1
q2.recipient = u1
q1.game = g1
q2.game = g1
db.session.add_all([u1, u2, u3, q1, q2, g1])
db.session.commit()
u1.last_question_read_time = datetime.utcnow()
q2.timestamp = datetime.utcnow()
db.session.commit()
with self.client:
self.client.post(url_for('auth.login'),
data={
'email': '*****@*****.**',
'password': '******'
})
# test that only q2 appears (since q1.timestamp < u1.last_question_read_time)
response = self.client.get(url_for('questions.list'))
data = response.get_data(as_text=True)
self.assertTrue('Game Against three' in data)
self.assertFalse('Game Against two' in data)
def create_games():
data = request.get_json(force=True)
print(data)
if data['originalDate'] != None:
originalDate = helper.format_date(data['originalDate'])
else:
originalDate = None
if data['originalTime'] != None:
originalTime = helper.format_time(data['originalTime'])
else:
originalTime = None
new_game = Game(schedule_status=data['scheduleStatus'],
original_date=originalDate,
original_time=originalTime,
delayed_or_postponed_reason=data['delayedOrPostponedReason'],
date=helper.format_date(data['date']),
time=helper.format_time(data['time']),
away_team_id = Team.query.filter_by(name=data['awayTeam']['Name']).first().id,
home_team_id = Team.query.filter_by(name=data['homeTeam']['Name']).first().id,
location=data['location'])
db.session.add(new_game)
db.session.commit()
return 'hi'
def create_game(chat, timeslot) -> Game:
"""Creates new game"""
game = Game(timeslot=timeslot)
game.create()
current_chat = get_chat(chat)
current_chat.add_game(game)
return game
def addgame():
teams = Team.query.order_by(Team.teamname).all()
teams_list = [(t.id, t.teamname) for t in teams]
form = AddGameForm()
form.team1.choices = teams_list
form.team2.choices = teams_list
if form.validate_on_submit():
date = form.date.data
team1 = form.team1.data
team2 = form.team2.data
score_team1 = form.score_team1.data
score_team2 = form.score_team2.data
winner = team1
loser = team2
if score_team1 < score_team2:
winner = team2
loser = team1
game = Game(date=date,
team1_id=team1,
team2_id=team2,
score_team1=score_team1,
score_team2=score_team2,
winner_team_id=winner,
loser_team_id=loser)
db.session.add(game)
db.session.commit()
flash('New game was added')
return redirect(url_for('addgame'))
return render_template('addgame.html', title='Add new game', form=form)
def move_rematch(game_id):
url = url_for('chess')
app.logger.info(game_id)
error = True
try:
game = Game.query.filter_by(id=game_id).first()
app.logger.info(game)
new_game = Game(player_one=game.player_two,
player_two=game.player_one,
time_limit=game.time_limit)
Game.insert(new_game)
answer = new_game.id
app.logger.info(answer)
if session['userId']:
player = Player.query.filter_by(id=session['userId']).first()
player.location = 'accepted ' + str(answer)
Player.update(player)
else:
error = True
db.session.rollback()
except:
app.logger.info(sys.exc_info())
error = True
db.session.rollback()
finally:
db.session.close()
if error:
return json.dumps({'error': 'data base error'})
return json.dumps({'status': 'redirect', 'id': answer, 'url': url})
def utils():
if args['init'] == True:
logging.info(
f"initializing database: {args['dburi'] + args['dbname']}")
initialize_db(app, args)
logging.info(f"database initialized")
if args['newgame'] != "":
logging.info(f"creating new game...")
new_game_number = Game.query.count() + 1
game_name_tally = ""
if (args['newgame'] == game_name_default):
game_name_tally = str(new_game_number)
game = Game(name=args['newgame'] + game_name_tally)
db.session.add(game)
db.session.commit()
logging.info(f"Populating game tables for {game.name}.")
if init_game(game) == True:
logging.info(
f"Populating game tables was successful for {game.name}")
else:
logging.info(
f"There were problems populating game tables for {game.name}")
def newgame():
maxg = Game.query.join(User, Game.user_id == User.id).filter(
User.username == current_user.username).order_by(
Game.gid.desc()).first()
if maxg:
maxid = maxg.gid #该用户当前的游戏最大场次
else:
maxid = 0
g = Game(gid=maxid + 1,
stage=1,
user_id=current_user.id,
start_time=datetime.utcnow(),
last_time=datetime.utcnow(),
state=1,
ps='无') #向数据库中添加新游戏场次
db.session.add(g)
db.session.commit()
gameid = Game.query.filter_by(gid=maxid + 1,
user_id=current_user.id).first_or_404().id
d = Decision1(gameid=gameid) #初始化decision1
db.session.add(d)
db.session.commit()
d = Decision2(dc='', location=0, gameid=gameid)
db.session.add(d)
db.session.commit()
return redirect(url_for('decisions_1', gameid=gameid))
def create_single_player_game(self) -> Tuple:
ensure_ai_user()
player_one_id = self.create_player_one()
data = {"players": [player_one_id]}
game = Game(**data)
loop = asyncio.get_event_loop()
loop.run_until_complete(game.commit())
return game.pk.__str__(), player_one_id
def test_create_player_db(self):
game = Game(players=['player1', 'player2', 'player3'])
db.session.add(game)
db.session.commit()
for player in game.players:
#confirm player created and associated to game
assert player.id
assert player.game_id
def set_game_id():
"""Set a room ID to DB"""
game = Game()
db.session.add(game)
db.session.commit()
game_id = game.id
db.session.close()
return game_id
def create_game(self) -> str:
player_one_id = self.create_player_one()
player_two_id = self.create_player_two()
data = {"players": [player_one_id, player_two_id]}
game = Game(**data)
loop = asyncio.get_event_loop()
loop.run_until_complete(game.commit())
return game.pk.__str__()
def create_game(game):
image = game['background_image']
if image is None:
image = defaultImage
new_game = Game(game=game['name'], image_path=image)
db.session.add(new_game)
db.session.commit()
return new_game
def editgame():
form = GameForm()
if form.validate_on_submit():
game = Game(title=form.title.data, body=form.body.data)
db.session.add(game)
db.session.commit()
return redirect(url_for('admin.index'))
return render_template('editgame.html', title='Editgame', form=form)
def add_game():
name = request.json['name']
description = request.json['description']
num_of_players = request.json['num_of_players']
new_game = Game(name, description, num_of_players)
db.session.add(new_game)
db.session.commit()
return game_schema.jsonify(new_game)
def respond_to_challenge(challenge: Challenge, accept: bool):
challenge.accept = accept
if accept:
game = Game(challenge.white_id,
challenge.black_id,
challenge.initial_fen,
timecontrol=challenge.timecontrol)
session.add(game)
challenge.game_id = game.id
emit('challenge_response', dumps(challenge))
def create_game():
form = GameAddForm()
if form.validate_on_submit() and form.password.data == app.config['PASSWORD_KEY']:
flash(f'creating Game {form.game.data}')
game = Game(name=form.game.data, url=form.url.data)
db.session.add(game)
db.session.commit()
return redirect('/index')
return render_template('game.html', title='create game', form=form)
def test_accept_invite(self):
u1 = User(username='******', email='*****@*****.**', password='******')
u2 = User(username='******', email='*****@*****.**', password='******')
u3 = User(username='******', email='*****@*****.**', password='******')
g1 = Game(author=u2, guest=u1, status='not_confirmed')
g2 = Game(author=u2, guest=u1, status='author_win')
g3 = Game(author=u3, guest=u2, status='not_confirmed')
db.session.add_all([u1, u2, u3, g1, g2, g3])
db.session.commit()
with self.client:
self.client.post(url_for('auth.login'),
data={
'email': '*****@*****.**',
'password': '******'
})
# invalid game
response = self.client.get(
url_for('games.accept_invite', game_id=100))
self.assertEqual(response.status_code, 404)
# user not game guest
response = self.client.get(url_for('games.accept_invite',
game_id=g3.id),
follow_redirects=True)
self.assertEqual(response.status_code, 403)
# game status is not 'not_confirmed'
response = self.client.get(url_for('games.accept_invite',
game_id=g2.id),
follow_redirects=True)
data = response.get_data(as_text=True)
self.assertTrue(
'The current game is not awaiting confirmation.' in data)
self.assertEqual(g2.status, 'author_win')
# success
self.assertEqual(g1.status, 'not_confirmed')
response = self.client.get(url_for('games.accept_invite',
game_id=g1.id),
follow_redirects=True)
data = response.get_data(as_text=True)
self.assertNotEqual(g1.status, 'not_confirmed')
def post(self):
try:
data = GamesList.parser.parse_args()
if Game.find_by_name(data['name']):
return msg('A game called "{}" already exists'.format(data['name'])), 400
game = Game(**data)
game.save_to_db()
return msg('Game created!'), 201
except:
return msg('There was an error creating your game')
def index():
form = CreateGameFrom()
if form.validate_on_submit():
game = Game()
db.session.add(game)
db.session.commit()
next_page = url_for('game')
next_page = url_for('game', variable=game.UUID)
return redirect(next_page)
return render_template('index.html', title='Home', form=form)
