Project_Steam_Tracker/run.py

import json
from flask import Flask, render_template, request, Response
import ss
import stats
import steam_api


RPI = False  # ZET NAAR TRUE ALS JE OP EEN RPI DRAAIT MET DE JUISTE LIBRARIES, ZODAT DE HARDWARE TAB WERKT


if RPI:
    import hw_funcs


app = Flask(__name__)  # flask app initialiseren
state_schuifregister = 0  # deze 3 waardes slaan de status op van de hardware onderdelen
state_ledstrip = '000000'
state_servo = 0


# lees json bestand en maak de tabel structuur aan, data_tpl
with open('steam.json') as file:
    # laad de json in een list
    blob = json.load(file)

    # lege lijst aanmaken
    temp_biglst = []

    # voor elke item in de list
    for i in blob:
        # voeg elke regel in de item toe aan een tijdelijke list
        temp_lst = [i['appid'], i['name'], i['release_date'], i['english'], i['developer'], i['publisher'],
                    i['platforms'], i['required_age'], i['categories'], i['genres'], i['steamspy_tags'],
                    i['achievements'], i['positive_ratings'], i['negative_ratings'], i['average_playtime'],
                    i['median_playtime'], i['owners'], i['price']]

        # zet de tijdelijke lijst om in een tuple
        temp_tpl = tuple(temp_lst)
        # voeg de tijdelijke list toe in de datalijst
        temp_biglst.append(temp_tpl)

    # datalijst omzetten in tuple, dit is de globale variabele die opgeroepen mag worden
    data_tpl = tuple(temp_biglst)

    # geheugen/variabelen vrijmaken
    del blob, temp_biglst, temp_lst, temp_tpl


@app.route('/')
def root():
    entries = []

    # sorteer op de meest aantal gebruikers
    data_lst = ss.nest_qsort(data_tpl, 16, True)

    genre = stats.popgenre(data_tpl)

    prijsmed = stats.median_prijs(data_tpl)

    # limiteer tabel tot en met 15 entries
    for x in range(0, 15):
        entries.append(data_lst[x])

    return render_template('index.html', first_entry=data_tpl[0], sizedb=len(data_tpl), entries=entries, genre=genre,
                           prijsmed=prijsmed)


@app.route('/fulltable')
def fulltable():
    max_rows_per_page = request.args.get('r', 100, int)

    if max_rows_per_page == -1:
        max_rows_per_page = len(data_tpl)

    entries = []

    if request.args.get('reverse') == 'True':
        reverse = True
    else:
        reverse = False

    if request.args.get('sortby') == "name":
        data_lst = ss.nest_qsort(data_tpl, 1, reverse)
    elif request.args.get('sortby') == "release_date":
        data_lst = ss.nest_qsort(data_tpl, 2, reverse)
    elif request.args.get('sortby') == "users":
        data_lst = ss.nest_qsort(data_tpl, 16, reverse)
    elif request.args.get('sortby') == "price":
        data_lst = ss.nest_qsort(data_tpl, 17, reverse)
    else:
        data_lst = data_tpl  # hoezo memory efficient werken?

    for x in range(0, max_rows_per_page):
        entries.append(data_lst[x])

    return render_template('fulltable.html', first_entry=data_tpl[0], entries=entries, reverse=not reverse)


@app.route('/hardware')
def hardware():
    return render_template('hardware.html', RPI=RPI)


@app.route('/search')
def search():
    query = request.args.get('q')  # de request argument q opslaan in variabele query

    entries = ss.nest_search(data_tpl, query)  # de data_tpl doorzoeken voor de waarde query, entries wordt een list

    return render_template('search.html', entries=entries)


@app.route('/app/<appid>')
def app_appid(appid):
    data = steam_api.getappdata(appid)  # applicatie data van steam opvragen en opslaan in variabele data
    return render_template('app.html', data=data[appid])


@app.route('/api/afstandsensor')
def api_afstandsensor():
    """Dit pad geeft een json array met de key 'afstand' met waarde van de afstandsensor in cm """
    if not RPI:
        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)

    return {'afstand': hw_funcs.poll_sensor()[0]}


@app.route('/api/schuifregister', methods=['POST', 'GET'])
def api_schuifregister():
    """
    Door het opvragen van dit pad met de GET functie is het mogelijk om de status van het schuifregister uit te lezen.
    Door te POST'en naar dit pad met de waarde 'setstate' is het mogelijk om de status aan te passen.
    """
    if not RPI:
        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)

    global state_schuifregister

    if request.method == 'POST':
        desired_state = request.form['setstate']

        try:
            hw_funcs.set_register(int(desired_state))
        except:
            return {'request': 'False'}

        print(f'Set value for schuifregister {desired_state}')
        state_schuifregister = desired_state
        return {'request': 'True'}
    else:
        return {'state': state_schuifregister}


@app.route('/api/servo', methods=['POST', 'GET'])
def api_servo():
    """
    Door het opvragen van dit pad met de GET functie is het mogelijk om de status van de servo uit te lezen.
    Door te POST'en naar dit pad met de waarde 'setstate' is het mogelijk om de status aan te passen.
    """
    if not RPI:
        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)

    global state_servo

    if request.method == 'POST':
        desired_state = request.form['setstate']

        try:
            hw_funcs.set_servo(int(desired_state))
        except:
            return {'request': 'False'}

        print(f'Set value for servo {desired_state}')
        state_servo = desired_state
        return {'request': 'True'}
    else:
        return {'state': state_servo}


@app.route('/api/pushbutton')
def api_pushbutton():
    """Dit pad geeft de status van de pushbuttons af in True en False, de keys alsvolgd genoemd: button0, button1"""
    if not RPI:
        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)

    if hw_funcs.poll_button():
        return {'button0': True}
    else:
        return {'button0': False}


@app.route('/api/ledstrip', methods=['POST', 'GET'])
def api_ledstrip_set():
    """
    Door het opvragen van dit pad met de GET functie is het mogelijk om de status van de ledstrip uit te lezen.
    Door te POST'en naar dit pad met de waarde 'setstate' is het mogelijk om de status aan te passen.
    """
    if not RPI:
        return Response('Hardware kan niet aangestuurt worden omdat het niet op een RPI draait!', status=418)

    global state_ledstrip

    if request.method == 'POST':
        string_state = request.form['setstate']

        try:
            # we ontvangen de volgenende waarde '#XXXXXX' maar de driver ondersteunt alleen hex in integer
            desired_state = int(string_state[1:], 16)
            hw_funcs.set_strip(desired_state)
        except:

            return {'request': 'False'}

        print(f'Set value for ledstrip {string_state}')
        state_ledstrip = string_state
        return {'request': 'True'}
    else:
        return {'state': state_ledstrip}


if __name__ == "__main__":
    app.run('0.0.0.0', port=5001, debug=True)