def viewdata(id):
db = get_db()
db = get_db()
player = db.execute(
"SELECT p.id, playernumber, username, referee_id"
" FROM player p"
" JOIN game g"
" JOIN user u"
" ON p.game_id = g.id AND p.user_id = u.id"
" WHERE p.id = (?)",
(id, ),
).fetchone()
if player["referee_id"] != g.user["id"]:
abort(403)
if request.method == "POST":
viewdata = request.form["viewdata"]
error = None
if not viewdata:
error = "viewdata is required."
if error is not None:
flash(error)
else:
db = get_db()
db.execute("UPDATE player SET viewdata = ? WHERE id = ?",
(viewdata, id))
db.commit()
return "Submitted viewdata for " + player['username']
return jsonify(player)
def register():
# If the user submitted the form, request.method will be 'POST'.
# In this case, start validating the input.
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
db = get_db()
error = None
# Validate that username and password are not empty.
if not username:
error = 'Username is required.'
elif not password:
error = 'Password is required.'
# Validate that username is not already registered by querying
# the database and checking if a result is returned
elif db.execute('SELECT id FROM user WHERE username = ?',
(username, )).fetchone() is not None:
error = 'User {} is already registered.'.format(username)
# insert the new user data into the database
if error is None:
db.execute('INSERT INTO user (username, password) VALUES (?, ?)',
(username, generate_password_hash(password)))
db.commit()
# redirected to the login page
return redirect(url_for('auth.login'))
# If validation fails, the error is shown
flash(error)
return render_template('auth/register.html')
def get_player(id, check_user=True):
"""Get a post and its author by id.
Checks that the id exists and optionally that the current user is
the author.
:param id: id of post to get
:param check_user: require the current user to be the author
:return: the post with author information
:raise 404: if a post with the given id doesn't exist
:raise 403: if the current user isn't the author
"""
db = get_db()
player = db.execute(
"SELECT p.id, playernumber, gamename, username, p.user_id"
", commanddata"
" FROM player p"
" JOIN game g"
" JOIN user u"
" ON p.game_id = g.id AND p.user_id = u.id"
" WHERE p.id = (?)",(id,),
).fetchone()
if player is None:
abort(404, "Player id {0} doesn't exist.".format(id))
if check_user and player["user_id"] != g.user["id"]:
abort(403)
return player
def dashboard():
db = get_db()
trades = db.execute(
'SELECT * FROM trade ORDER BY date ASC'
).fetchall()
dates = []
results = []
result_sum = 0
each_result = []
win = []
lose = []
win_count = 0
lose_count = 0
for trade in trades:
date = datetime.datetime.strftime(trade['date'], '%Y-%m-%d')
dates.append(date)
result_sum = result_sum + trade['result']
results.append(result_sum)
each_result.append(trade['result'])
if trade['result']> 0:
win.append(trade['result'])
win_count += 1
elif trade['result'] < 0:
lose.append(trade['result'])
lose_count += 1
all_sum = sum(each_result)
win_sum = round(sum(win) / win_count, 1)
lose_sum = round(sum(lose) / lose_count, 1)
trade_count = len(results)
win_ratio = round(win_count / trade_count * 100, 1)
risk_reward = abs(round(win_sum / lose_sum, 1))
return render_template('trade/dashboard.html', dates=dates, results=results, all_sum=all_sum, win_sum=win_sum, lose_sum=lose_sum, trade_count=trade_count, win_ratio=win_ratio,risk_reward=risk_reward)
def login():
# user is queried first and stored in a variable
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
db = get_db()
error = None
user = db.execute('SELECT * FROM user WHERE username = ?',
(username, )).fetchone()
if user is None:
error = 'Incorrect username.'
elif not check_password_hash(user['password'], password):
error = 'Incorrect password.'
if error is None:
# session is a dict that stores data across requests.
# When validation succeeds, the user’s id is stored in a new session
session.clear()
session['user_id'] = user['id']
return redirect(url_for('index'))
flash(error)
return render_template('auth/login.html')
def join(id):
db = get_db()
player = db.execute(
"SELECT p.id, playernumber, gamename, p.user_id"
" FROM player p"
" JOIN game g"
" ON p.game_id = g.id"
" WHERE p.id = (?)",(id,),
).fetchone()
if player['user_id'] is not None:
player = get_player(id, check_user=False)
abort(403, "Player already occupied by {0}.".format(player['username']))
user_id = g.user['id']
db.execute(
"UPDATE player"
" SET user_id = ?"
" WHERE id = ?",(user_id, id,),
)
db.commit()
player = get_player(id, check_user=False)
return jsonify(player)
def login():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
db = get_db()
error = None
user = db.execute(
'SELECT * FROM user WHERE username = ?', (username,)
).fetchone()
if user is None:
error = 'User {} does not exist'.format(username)
elif not check_password_hash(user['password'], password):
error = 'Password not correct'
if error is None:
session.clear()
session['user_id'] = user['id']
session['username'] = user['username']
return redirect(url_for('index'))
flash(error)
return render_template('auth/login.html')
def login():
"""Log in a registered user by adding the user id to the session."""
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
db = get_db()
error = None
user = db.execute(
"SELECT * FROM user WHERE username = ?", (username,)
).fetchone()
if user is None:
error = "Incorrect username."
elif not check_password_hash(user["password"], password):
error = "Incorrect password."
if error is None:
# store the user id in a new session and return to the index
session.clear()
session["user_id"] = user["id"]
if request.args.get('type') == 'json':
return myprofile()
return redirect(url_for("index"))
flash(error)
return render_template("auth/login.html")
def register():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
db = get_db()
error = None
if not username:
error = 'Username is required.'
elif not password:
error = 'Password is required.'
elif db.execute(
'SELECT id FROM user WHERE username = ?', (username,)
).fetchone() is not None:
error = 'User {} is already registered.'.format(username)
if error is None:
db.execute(
'INSERT INTO user (username, password) VALUES (?, ?)',
(username, generate_password_hash(password))
)
db.commit()
return redirect(url_for('auth.login'))
flash(error)
return render_template('auth/register.html')
def app():
app = create_app({'Testing': True, 'DATABASE': props.SQLALCHEMY_DATABASE_URI})
with app.app_context():
push_to_db()
result = get_db().engine.execute(_data_sql)
yield app
def get_trade(id):
db = get_db()
trade = db.execute(
'SELECT date, pare, amount, result FROM trade WHERE id = ?', (id,)
).fetchone()
if trade is None:
abort(404, 'There is not such a trade')
return trade
def load_logged_in_user():
user_id = session.get('user_id')
if user_id is None:
g.user = None
else:
g.user = get_db().execute('SELECT * FROM user WHERE id = ?',
(user_id, )).fetchone()
def index():
db = get_db()
posts = db.execute(
'SELECT p.id, title, body, created, author_id, username'
' FROM post p JOIN user u ON p.author_id = u.id'
' ORDER BY created DESC'
).fetchall()
return render_template('blog/index.html', posts=posts)
def history():
db = get_db()
trades = db.execute(
'SELECT * FROM trade ORDER BY date DESC'
).fetchall()
page = request.args.get(get_page_parameter(), type=int, default=1)
per_page = 10
page_trades = trades[(page-1)*per_page: page*per_page]
pagination = Pagination(page=page, total=len(trades), per_page=per_page, css_framework='bootstrap4')
return render_template('trade/history.html', trades=page_trades, pagination=pagination)
def commanddata(id):
"""Update a post if the current user is the author."""
db = get_db()
player = db.execute(
"SELECT commanddata"
" FROM player p"
" WHERE p.id = (?)",(id,),
).fetchone()
return jsonify(player)
def mygames():
db = get_db()
games = db.execute(
"SELECT g.id, gamename, turnnum"
" FROM game g"
" WHERE g.referee_id = ?",
(g.user['id'], ),
).fetchall()
return jsonify({"Items": games})
def get_user(username):
db = get_db()
user = db.execute('SELECT id FROM user WHERE username = ?',
(username, )).fetchone()
if user is not None:
return user['id']
else:
return None
def myplayers():
db = get_db()
players = db.execute(
"SELECT p.id, gamename, p.user_id, playernumber"
" FROM player p"
" JOIN game g"
" ON p.user_id = ? AND p.game_id = g.id",
(g.user['id'], ),
).fetchall()
return jsonify({"Items": players})
def load_logged_in_user():
"""If a user id is stored in the session, load the user object from
the database into ``g.user``."""
user_id = session.get("user_id")
if user_id is None:
g.user = None
else:
g.user = (
get_db().execute("SELECT * FROM user WHERE id = ?", (user_id,)).fetchone()
)
def turndata(id):
db = get_db()
game = db.execute(
"SELECT id, referee_id, turndata, turnnum, gamename"
" FROM game g"
" WHERE g.id = (?)",
(id, ),
).fetchone()
if game["referee_id"] != g.user["id"]:
abort(403)
if request.method == "POST":
turndata = request.form["turndata"]
turnnum = int(request.form["turnnum"])
error = None
if not turndata:
error = "turndata is required."
if not turnnum:
error = "turnnum is required."
currentturnnum = int(game["turnnum"])
if turnnum <= currentturnnum:
error = "turnnum " + turnnum + " is <= game turnnum " + currentturnnum
if error is not None:
flash(error)
else:
db = get_db()
db.execute(
"UPDATE game SET turndata = ?, turnnum = ? WHERE id = ?",
(turndata, turnnum, id))
db.commit()
return "Submitted turndata for " + game['gamename']
# return redirect(url_for("blog.index"))
return jsonify(game)
def update(id):
trade = get_trade(id)
if request.method == 'POST':
date = request.form['date']
pare = request.form['pare']
amount = request.form['amount']
result = request.form['result']
db = get_db()
db.execute(
'UPDATE trade SET date=?, pare=?, amount=?, result=? WHERE id=?', (date, pare, amount, result, id)
)
db.commit()
return redirect(url_for('trade.history'))
return render_template('trade/update.html', trade=trade)
def get_post(id, check_author=True):
db = get_db()
post = db.execute(
'SELECT p.id, title, body, created, author_id, username'
' FROM post p JOIN user u ON p.author_id = u.id'
' WHERE p.id = ?', (id, )).fetchone()
if post is None:
abort(404, "Post id {0} doesn't exist.".format(id))
if check_author and post['author_id'] != g.user['id']:
abort(403)
return post
def submit(id):
"""Update a post if the current user is the author."""
db = get_db()
player = db.execute(
"SELECT p.id, playernumber, gamename, username, p.user_id, commanddata"
", commanddata"
" FROM player p"
" JOIN game g"
" JOIN user u"
" ON p.game_id = g.id AND p.user_id = u.id"
" WHERE p.id = (?)",(id,),
).fetchone()
if player['commanddata'] is not None:
abort(403, "Player {0} {1} has already submitted their turn".format(player['id'], player['username']))
if request.method == "POST":
commanddata = request.form["commanddata"]
error = None
if not commanddata:
error = "commanddata is required."
if error is not None:
flash(error)
else:
db = get_db()
db.execute(
"UPDATE player SET commanddata = ? WHERE id = ?", (commanddata, id)
)
db.commit()
return "Submitted orders for "+player['username']
# return redirect(url_for("blog.index"))
# return jsonify(player)
return render_template("player/submit.html", player=player)
def create():
if request.method == 'POST':
date = request.form['date']
pare = request.form['pare']
amount = request.form['amount']
result = request.form['result']
db = get_db()
db.execute(
'INSERT INTO trade (user_id, date, pare, amount, result)'
'VALUES (?,?,?,?,?)',(g.user['id'], date, pare, amount, result)
)
db.commit()
return redirect(url_for('trade.history'))
return render_template('trade/create.html')
def players():
db = get_db()
# players = db.execute(
# "SELECT gamename, username"
# " FROM player p"
# " JOIN game g"
# " JOIN user u"
# " ON p.game_id = g.id AND p.user_id = u.id"
# ).fetchall()
players = db.execute("SELECT p.id, gamename, p.user_id, playernumber"
" FROM player p"
" JOIN game g"
" ON p.game_id = g.id").fetchall()
if request.args.get('type') == 'json':
return jsonify(players)
return render_template("intro/index.html", players=players)
def register():
if request.method == 'POST':
keyword = request.form['keyword']
error = None
db = get_db()
if not keyword:
error = 'Keyword is required'
elif db.execute('SELECT id FROM keyword WHERE text = ?;',
(keyword, )).fetchone() is not None:
error = f'Keyword {keyword} is already registered.'
if error is None:
db.execute('INSERT INTO keyword (text) VALUES (?);', (keyword, ))
db.commit()
return redirect(url_for('keyword.index'))
flash(error)
return render_template('keyword/register.html')
def register():
"""Register a new user.
Validates that the username is not already taken. Hashes the
password for security.
"""
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
db = get_db()
error = None
if not username:
error = "Username is required."
elif not password:
error = "Password is required."
elif (
db.execute("SELECT id FROM user WHERE username = ?", (username,)).fetchone()
is not None
):
error = "User {0} is already registered.".format(username)
if error is None:
# the name is available, store it in the database and go to
# the login page
db.execute(
"INSERT INTO user (username, password) VALUES (?, ?)",
(username, generate_password_hash(password)),
)
db.commit()
# db.execute(
# "INSERT INTO post (nickname, score, author_id) VALUES (?, ?, ?)",
# (username, 0, g.user["id"]),
# )
# db.commit()
return redirect(url_for("auth.login"))
flash(error)
return render_template("auth/register.html")
def update(id):
post = get_post(id)
if request.method == 'POST':
title = request.form['title']
body = request.form['body']
error = None
if not title:
error = 'Title is required.'
if error is not None:
flash(error)
else:
db = get_db()
db.execute('UPDATE post SET title = ?, body = ?'
' WHERE id = ?', (title, body, id))
db.commit()
return redirect(url_for('blog.index'))
return render_template('blog/update.html', post=post)
def commanddata(id):
db = get_db()
game = db.execute(
"SELECT g.id, gamename, referee_id"
" FROM game g"
" WHERE g.id = (?)",
(id, ),
).fetchone()
if game["referee_id"] != g.user["id"]:
abort(403)
players = db.execute(
"SELECT p.id, commanddata"
" FROM player p"
" WHERE p.game_id = (?)",
(id, ),
).fetchall()
return jsonify({"Items": players})
def index():
db = get_db()
games = db.execute(
"SELECT g.id, gamename, g.created, summary, username, referee_id"
" FROM game g"
" JOIN user u"
" ON g.referee_id = u.id"
" ORDER BY g.created DESC").fetchall()
players = {}
for game in games:
players[game['id']] = db.execute(
"SELECT p.id, playernumber, username, user_id, turnnum"
" FROM player p"
" JOIN user u"
" JOIN game g"
" ON p.user_id = u.id AND p.game_id = g.id"
" WHERE game_id = (?)",
(game['id'], ),
).fetchall()
openseats = {}
for game in games:
openseats[game['id']] = db.execute(
"SELECT id, playernumber"
" FROM player p"
" WHERE p.user_id IS null AND game_id = (?)",
(game['id'], ),
).fetchall()
if request.args.get('type') == 'json':
# return jsonify(games)
return jsonify(openseats)
print(players)
print(openseats)
return render_template("intro/index.html",
games=games,
players=players,
openseats=openseats)
