influx_stats/influx_frontend.py

from flask import Flask, request, render_template, redirect, url_for
from time import strftime
import pendulum
from dotenv import dotenv_values
import influxdb_client
from influxdb_client.client.write_api import SYNCHRONOUS
from operator import itemgetter


config = dotenv_values(".env")

app = Flask(__name__)

client = influxdb_client.InfluxDBClient(
    url=config['DB_URL'],
    token=config['DB_TOKEN'],
    org=config['DB_ORG']
)


@app.route('/success')
def success():
    return "Form success!"


def fetch_timeseries_data(timestamp=None):
    query_api = client.query_api()
    if timestamp is not None:
        newTime = pendulum.parse(timestamp)
        print(newTime.to_atom_string())
        # "2023-11-14T08:21:00.000Z"
        query = 'from(bucket: "gas")\
        |> range(start: time(v: "' + str(newTime.subtract(seconds=1).to_atom_string()) + '"), stop: time(v: "' + str(newTime.add(seconds=1).to_atom_string()) + '"))\
        |> filter(fn: (r) => r["_measurement"] == "2016_odyssey")\
        |> filter(fn: (r) => r["_field"] == "odometer")\
        |> sort(columns: ["_value"], desc: false)\
        |> yield(name: "last")\
        |> limit(n:10)'
        print("searching for fixed time")
    else:
        query = 'from(bucket: "gas")\
        |> range(start: -90d)\
        |> filter(fn: (r) => r["_measurement"] == "2016_odyssey")\
        |> filter(fn: (r) => r["_field"] == "odometer")\
        |> sort(columns: ["_value"], desc: false)\
        |> yield(name: "last")\
        |> limit(n:10)'

    result = query_api.query(org=config['DB_ORG'], query=query)
    results = []
    for table in result:
        for record in table.records:
            temp = {}
            temp[record.get_field()] = record.get_value()
            temp['time'] = record.get_time()
            try:
                temp['oilhealth'] = record['oilhealth']
            except KeyError:
                pass
            try:
                temp['fuel'] = record['fuel']
                temp['fuelcost'] = record['fuelcost']
            except KeyError:
                pass
            try:
                temp['winter'] = record['winter']
            except KeyError:
                pass
            results.append(temp)
            # .append((record.get_time(), record.get_field(), record.get_value()))
    newlist = sorted(results, key=itemgetter('time'), reverse=True)
    oldlist = newlist  # temporary to strip the non-unique data
    newlist = []
    for value in oldlist:
        if value in newlist:
            continue
        else:
            newlist.append(value)
    print(newlist)
    print()
    return newlist


@app.route('/', methods=['GET', 'POST'])
def main_page():
    # Call fetch function
    newlist = fetch_timeseries_data()
    # print(newlist)
    return render_template('index.html', data=newlist[:10])


@app.route('/add_time', methods=['POST', 'GET'])
def add_time():
    today = strftime("%Y-%m-%d")
    now = strftime("%H:%M:%S")
#    database = request.form['db']
#    table = request.form['table']
    date = request.form['date']
    if date == '':
        date = today
    time = request.form['time']
    if time == '':
        time = now
    odometer = request.form['odometer']
    oilhealth = request.form['oilhealth']
    if oilhealth != '':
        oilhealth = float(oilhealth)
    fuel = request.form['fuel']
    if fuel != '':
        fuel = float(fuel)
    fuelcost = request.form['fuelcost']
    if fuelcost != '':
        fuelcost = float(fuelcost)
    winter = request.form['winter']
    if winter == 'TRUE':
        winter = 1
    else:
        winter = 0

    json_body = [
        {
            "time": date + "T" + time + "Z",
            "measurement": "odyssey",
            "fields": {
                "odometer": float(odometer),
                "oilhealth": oilhealth,
                "fuel": fuel,
                "fuelcost": fuelcost,
                "winter": winter
            }
        }
    ]

    timestamp = date + "T" + time + "Z"
    dt = pendulum.parse(timestamp)
    print()
    print(dt)
    print()
    write_api = client.write_api(write_options=SYNCHRONOUS)
    point = influxdb_client.Point("2016_odyssey").time(timestamp).tag("oilhealth", oilhealth)\
        .tag("fuel", fuel).tag("fuelcost", fuelcost).tag("winter", winter).field("odometer", float(odometer))
    write_api.write(bucket="gas", org=config['DB_ORG'], record=point)
    print("Submitting data to DB: {0}".format(json_body))
    # client.write_points(json_body)

    return redirect(url_for('main_page'))


@app.route('/edit/<timestamp>')
def edit_odometer_entry(timestamp):
    '''Retrieve the time entry from influxdb'''
    print('Fetching data!')
    # Call fetch function
    newlist = fetch_timeseries_data()

    # Fill entry_data with timestamp based data
    entry_data = fetch_timeseries_data(timestamp)
    return render_template('index.html', page_title="Edit Entry", timestamp_data=entry_data, data=newlist[:10])


@app.route('/repeat_last_odometer/<odometer>/<winter>')
def repeat_last_odometer(odometer, winter=False):
    '''Retrieve the passed in odometer value and submit as a new entry'''
    date = strftime("%Y-%m-%d")
    time = strftime("%H:%M:%S")
    timestamp = date + "T" + time + "Z"
    print("Putting %s to database for %s" % (odometer, timestamp))

    write_api = client.write_api(write_options=SYNCHRONOUS)
    point = influxdb_client.Point("2016_odyssey").time(
        timestamp).tag("winter", winter).field("odometer", float(odometer))
    write_api.write(bucket="gas", org=config['DB_ORG'], record=point)
    return redirect(url_for('main_page'))


@app.route('/admin')
def admin_index():
    return 'admin'


@app.route('/login')
def login():
    pass


@app.route('/logout')
def logout():
    pass


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