flask_app.py

from flask import Flask, render_template, session, request, redirect, flash, url_for
from flask import jsonify
import sqlite3
import uuid
import hashlib
import random
import platform
from datetime import datetime

# -------------------------------------------------------------------------------
# SETTINGS for the Flask Web Application
# -------------------------------------------------------------------------------
DATABASE = '/home/18choym/mysite/test.sqlite'
DEBUG = True

SECRET_KEY = 'my random key can be anything'  # this random sequence is required to encrypt Sessions
app = Flask(__name__)  # Creates a handle for the Flask Web Server
app.config.from_object(__name__)  # Set app configuration using above SETTINGS
sep = ' | '
# ---------------------------------------------------------------------------------------
# DATABASE HELPER FUNCTIONS


def connect_db():
    return sqlite3.connect(app.config['DATABASE'])


def make_dictionary(cursor, row):
    return dict((cursor.description[idx][0], value)
                for idx, value in enumerate(row))


# ---------------------------------------------------------------------
# Other helful functions!
# ---------------------------------------------------------------------

def hash_password(password):
    # uuid is used to generate a random number
    salt = uuid.uuid4().hex
    return hashlib.sha256(salt.encode() + password.encode()).hexdigest() + ':' + salt


# for decrypting the password in the database
def check_password(hashed_password, user_password):
    password, salt = hashed_password.split(':')
    return password == hashlib.sha256(salt.encode() + user_password.encode()).hexdigest()


def verifyEmail(email):
    atIndex = email.index('@')
    dotIndex = email.index('.')
    if atIndex > dotIndex:
        if email[-3:] == 'com':
            return True
        else:
            return False

def update_access(username):
    print(username)
    fmt = "%d/%m/%Y %H:%M:%S"
    datenow = datetime.now().strftime(fmt)
    db = connect_db()
    db.execute("UPDATE users SET lastaccess = ?, active = 1 where username = ?", (datenow, username))
    # db.execute("UPDATE users SET lastaccess = ?", (datenow))
    db.commit()
    db.close()
    return


def get_active_users():
    fmt = "%d/%m/%Y %H:%M:%S"
    db = connect_db()
    cursor = db.execute("SELECT username, lastaccess from users")
    users = cursor.fetchall()
    activeusers = []  # blank list
    for user in users:
        userdictionary = make_dictionary(cursor, user)
        td = datetime.now() - datetime.strptime(userdictionary['lastaccess'], fmt)
        if td.seconds < 120:  # TODO when publishing this code, change this to 120
            activeusers.append(userdictionary['username'])  # makes a list of names
    db.close()
    return activeusers
activeUsers = []
deck = []

def gen_cards():
    global deck

    card_val = ['ace', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'jack', 'queen', 'king']
    card_face = ['spades', 'clubs', 'diamonds', 'hearts']

    for i in card_face:
        for j in card_val:
            deck.append(j + '_of_' + i)
    return deck


def deal_card():
    random_idx = random.randint(0, int(len(deck)))
    random_idx -= 1
    single_card = deck.pop(random_idx)
    return single_card


def deal_players(players):
    for i in players:
        i.append(deal_card())
    return

def deal_to_player(playerIndex):
    global players
    cardToDeal = deal_card()
    players[playerIndex].append(cardToDeal)

itercounter = 0
numplayers = 0
players = []

my_dict = {'2': '2', '3': '3', '4': '4', '5': '5', '6': '6', '7': '7', '8': '8', '9': '9', '10': '10',
                'j': '10', 'q': '10', 'k': '10', 'a': '11'}
def score_cards(card):
    if type(card) == list:
        score = 0
        tmp = 0
        for i in card:
            if i[:2] == '10':
                score += 10
            else:
                first_index = str(i[0])
                print(str(type(first_index)))
                tmp = int(my_dict[first_index])
                score += tmp
    else:
        if card[:2] == '10':
            score = 10
        else:
            first_index = str(card[0])
            score = my_dict[first_index]
    return score
player_index = 0
currentPlayer = 0
gameSetupCompleted = False
numActiveUsers = 0
currentPlayerIndex = 0
scores = []
setupComplete = False
exitCode = False
playerLost = ''
score = 0
scores = []
lost = []
players = []

def iteratePlayerIndex():
    global currentPlayerIndex, scores
    maxIdx = len(scores)-1
    numNonZero = 0
    for i in scores:
        if i != 0:
            numNonZero += 1
    if numNonZero != 1:
        currentPlayerIndex += 1
        if currentPlayerIndex > maxIdx:
            currentPlayerIndex = 0
            # print(str(currentPlayerIndex) + '1')
        if scores[-1] != 0:
            while scores[currentPlayerIndex] == 0:
                currentPlayerIndex += 1
                # print(str(currentPlayerIndex) + '2')
        if scores[-1] == 0 and currentPlayerIndex == maxIdx:  #last element 0
            currentPlayerIndex = 0
            # print(str(currentPlayerIndex) + '3')
        if scores[0] == 0 and currentPlayerIndex == 0:
            currentPlayerIndex += 1
        print(currentPlayerIndex)



# HTTP Request Handlers------------------------------------------------------------------------
# Homepage for the application


@app.route('/blog', methods=['GET', 'POST'])
def blog():
    error = ""
    return render_template('blog.html', error=error)
username = ''


@app.route('/', methods=['GET', 'POST'])  # / means that homepage is referenced
def login():
    global username
    if 'userid' in session:
        return redirect("/page1")
    if request.method == "POST":
        username = request.form['username']
        password = request.form['password']
        update_access(username)
        db = connect_db()  # to database using predefined function
        cursor = db.execute("Select * from users where username = ?", (username,))
        row = cursor.fetchone()

        if row is None:
            flash("user does not exist")
        else:
            userdetails = make_dictionary(cursor, row)  # makes a dictionary from the cursor
            if userdetails['password'] != password:
                flash("incorrect password")
                # flash similar to print
            else:  # success
                session['userid'] = userdetails['userid']  # setting a dictionary, saving cookies
                session['permission'] = userdetails['permission']  # is the user an admin or not
                session['username'] = username  # simplifying user reference
                return redirect('/page1')
        db.close()
    else:
        flash("no data was posted")
    return render_template('login.html')


@app.route('/logoff')
def logoff():
    session.clear()
    return redirect('/')


@app.route('/page1', methods=['GET', 'POST'])
def page1():
    if 'userid' not in session:
        return redirect('/')
    return render_template('page1.html')


@app.route('/register', methods=['GET', 'POST'])
def register():
    return render_template('register.html')


@app.route('/registerData', methods=['GET', 'POST'])
def registerData():
    register = False
    db = connect_db()

    username = request.form['username']
    password = request.form['password']
    password2 = request.form['password2']
    email = request.form['email']
    fmt = "%d/%m/%Y %H:%M:%S"
    datenow = datetime.now().strftime(fmt)
    permission = 'user'
    active = 1

    cursor = db.execute("SELECT * FROM users WHERE active = 1")
    row = cursor.fetchall()
    for i in row:  # check if the username already exists
        if username == i[1] or verifyEmail(email) is True:
            flash('Account created. If this is your account, you can log in. Otherwise, choose another username.')
            register = True
            return redirect('/register')
    if verifyEmail(email) == False:
        return redirect('/register')
    if password != password2: # check if the passwords match
        flash('Passwords do not match.')

    else:
        if register is False:
            db.execute("INSERT INTO users (username, password, email, permission, lastaccess, active) VALUES "
                       "(?,?,?,?,?,?)", (username, password, email, permission, datenow, active))
            db.commit()
    # return(str(row))
    return redirect('/')


@app.route('/admin', methods=['GET', 'POST'])
def admin():
    db = connect_db()  # to database using predefined function
    cursor = db.execute("Select userid, username, email, lastAccess from users")
    # cursor = db.execute('SELECT * from users')
    usersTable = cursor.fetchall()

    cursor = db.execute("Select * from moves")
    movesTable = cursor.fetchall()

    return render_template('admin.html', usersTable=usersTable, movesTable=movesTable)


@app.route('/f', methods=['GET', 'POST'])
def f():
    db = connect_db()
    cursor = db.execute('SELECT lastaccess from users')
    row = cursor.fetchall()
    return str(row)


@app.route('/lobby', methods=['GET', 'POST'])
def lobby():
    activeUsers = get_active_users()
    global numplayers
    if 'userid' not in session:
        return redirect('/')
    if request.method == 'POST':  # Returns updated list of activeUsers
        requesttype = request.form.get('requesttype')
        if requesttype == 'GetUsers':
            numplayers = len(activeUsers)
            username = request.form.get('username')
            update_access(username)
            numberOfPlayers = 3  # The number of players required to start the game
            return jsonify({'userlist': activeUsers, 'numPlayers': numplayers,
                'numberOfPlayers':numberOfPlayers})
    return render_template('lobby.html')



@app.route('/game', methods=['GET', 'POST'])
def game():
    global players, setupComplete, currentPlayerIndex, deck, scores, score
    global lost, playerLost

    scoreType = []
    activeUsers = get_active_users()
    numplayers = len(activeUsers)
    if setupComplete is False:
        players = [[] for i in range(int(numplayers))]
        scores = []
        lost = []
        for i in range(numplayers):
            scores.append(int(0))
        for i in range(numplayers):
            lost.append(False)
        for i in range(numplayers):
            scoreType.append(False)
        gen_cards()
        deal_players(players)
        setupComplete = True
    if request.method == 'POST':
        # scoreType = []
        # for i in score:
        #     scoreType.append(str(type(i)))

        requesttype = request.form.get('requesttype')
        # print(str(requesttype)+sep+'requesttype')
        activeUsers = get_active_users()


        if requesttype == 'lost':
            '''
            If the user's score is above 21, the lost requesttype is called.
            '''
            stringToPrint = 'You have lost!!'
            username = request.form.get('username')
            userIndex = activeUsers.index(str(username))
            returnCode = 'Successful'
            scores[int(userIndex)] = 0
            return jsonify({'code': returnCode, 'userIndex':userIndex, 'scores':scores, 'lost':lost, 'stringToPrint':stringToPrint, 'scoreType':scoreType})


        if requesttype == 'get cards':
            '''
            This requesttype is called often and updates the user's display.
            '''
            username = request.form.get('username')
            print(str(activeUsers))
            userIndex = activeUsers.index(str(username))
            hand = players[userIndex]


            # DEBUG
            oldScores = scores[:]
            # DEBUG
            if scores[int(userIndex)] is not [0] or scores[int(userIndex)] is not '0' or scores[int(userIndex)] is not 0:
                score = int(score_cards(hand))
                scores[int(userIndex)] = score

            lostSend = str(lost)
            # return jsonify({'hand': hand, 'index': userIndex, 'score': score, 'username':username, 'scores':scores, 'players':players})
            return jsonify({'hand': hand, 'index': userIndex, 'score': score, 'username':username, 'scores':scores, 'players':players, 'lost':lostSend, 'oldScores':oldScores, 'scoreType':scoreType})


        if requesttype == 'validate move':
            '''
            request handler for updating a player's move.
            '''
            db = connect_db()
            move = request.form.get('move')
            print(str(move)+sep+'move')
            username = request.form.get('username')
            userIndex = activeUsers.index(str(username))
            db.execute("INSERT INTO moves (username, move) VALUES "
                       "(?,?)", (username, move))
            db.commit()
            if move == 'hit':
                deal_to_player(userIndex)
                hand = players[userIndex]

                if scores[int(userIndex)] is not [0] or scores[int(userIndex)] is not '0' or scores[int(userIndex)] is not 0:
                    scores[userIndex] = score_cards(hand)+1000
                    iteratePlayerIndex()
                    if scores[userIndex] > 21:
                        iteratePlayerIndex()
                        # return redirect('/')
                    elif scores[userIndex] == 0:
                        iteratePlayerIndex()
                        # return redirect('/')
                if scores[userIndex] > 21:
                    scores[userIndex] = 0
                iteratePlayerIndex()
            elif move == 'stand':
                iteratePlayerIndex()
            return jsonify ({'hand':hand, 'players':players, 'scores':scores, 'scoreType':scoreType})


        if requesttype == 'check if current user':
            '''
            updates buttons
            '''
            playerUsername = request.form.get('username')
            currentUserIndex = activeUsers.index(str(playerUsername))
            playerLost = request.form.get('lost')
            if playerLost == 'True':
                scores[currentUserIndex] = 0
                return jsonify({'currentPlayer': 'True', 'redirect':'True', 'scoreType':scoreType})
            if currentUserIndex == currentPlayerIndex:
                return jsonify({'currentPlayer': 'True', 'redirect':'False', 'scoreType':scoreType})
            else:
                return jsonify({'currentPlayer': 'False', 'redirect':'False', 'scoreType':scoreType})
    return render_template('game.html', numPlayers=numplayers, players=players, deck=deck, len=len(deck), activeUsers=activeUsers)

@app.route('/fmt', methods=['GET', 'POST'])
def fmt():
    return render_template('ajopisf.html')

@app.route('/machine', methods=['GET', 'POST'])
def machine():
    return str(platform.machine())
    # x86_64 for server and mac

@app.route('/layout')
def layout():
    return render_template('layout.html')

@app.route('/html')
def html():
    return render_template('main.html')