240 lines
7.3 KiB
Python
240 lines
7.3 KiB
Python
from datetime import date
|
|
from datetime import datetime
|
|
from flask import Flask
|
|
from flask import render_template, make_response
|
|
from flask import request, redirect, g
|
|
from flask import url_for
|
|
from flask_sqlalchemy import SQLAlchemy
|
|
import uuid
|
|
import hashlib
|
|
import time
|
|
from functools import wraps
|
|
|
|
app = Flask(__name__)
|
|
DATABASE = '/data/rollerverbrauch.db'
|
|
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'+DATABASE
|
|
sqldb = SQLAlchemy(app)
|
|
|
|
DEBUG = True
|
|
SECRET_KEY = 'development key'
|
|
app.config.from_object(__name__)
|
|
|
|
|
|
class User(sqldb.Model):
|
|
id = sqldb.Column(sqldb.Integer, primary_key=True)
|
|
username = sqldb.Column(sqldb.String(80), unique=True)
|
|
email = sqldb.Column(sqldb.String(120), unique=True)
|
|
salt = sqldb.Column(sqldb.String(8))
|
|
password_hash = sqldb.Column(sqldb.String(64))
|
|
|
|
def __init__(self, username, email, password):
|
|
self.username = username
|
|
self.email = email
|
|
self.salt = uuid.uuid4().hex
|
|
m = hashlib.sha256(password.encode('utf-8'))
|
|
m = hashlib.sha256((m.hexdigest() + self.salt).encode('utf-8')).hexdigest()
|
|
self.password_hash = m
|
|
pass
|
|
|
|
def __repr__(self):
|
|
return '<User %r>' % self.username
|
|
|
|
|
|
class Pitstop(sqldb.Model):
|
|
id = sqldb.Column(sqldb.Integer, primary_key=True)
|
|
date = sqldb.Column(sqldb.Date)
|
|
odometer = sqldb.Column(sqldb.Integer)
|
|
litres = sqldb.Column(sqldb.Numeric(5,2))
|
|
|
|
def __init__(self, odometer, litres, date):
|
|
self.odometer = odometer
|
|
self.litres = litres
|
|
self.date = date
|
|
|
|
def __repr__(self):
|
|
return '<Pitstop %r km, %r l>' % (self.odometer, self.litres)
|
|
|
|
sqldb.create_all()
|
|
if User.query.filter_by(username='jlusiardi').first() is None:
|
|
user1 = User('jlusiardi', 'joachim@lusiardi.de', 'pitstops')
|
|
sqldb.session.add(user1)
|
|
sqldb.session.commit()
|
|
|
|
|
|
def check_auth(username, password):
|
|
user = User.query.filter_by(username=username).first()
|
|
if user is None:
|
|
return False
|
|
salt = user.salt
|
|
m = hashlib.sha256(password.encode('utf-8'))
|
|
m = hashlib.sha256((m.hexdigest()+salt).encode('utf-8'))
|
|
digest = m.hexdigest()
|
|
ok = (User.query.filter_by(username=username, password_hash=digest).first() is not None)
|
|
if not ok:
|
|
app.logger.error("digest: " + digest)
|
|
return ok
|
|
|
|
|
|
def authenticate():
|
|
resp = make_response(render_template('login_required.html'), 401)
|
|
resp.headers['WWW-Authenticate'] = 'Basic realm="Login Required"'
|
|
return resp
|
|
|
|
|
|
def requires_auth(f):
|
|
@wraps(f)
|
|
def decorated(*args, **kwargs):
|
|
auth = request.authorization
|
|
if not auth or not check_auth(auth.username, auth.password):
|
|
return authenticate()
|
|
return f(*args, **kwargs)
|
|
return decorated
|
|
|
|
|
|
@app.before_request
|
|
def before_request():
|
|
g.data = {}
|
|
|
|
|
|
@app.teardown_request
|
|
def teardown_request(exception):
|
|
pass
|
|
|
|
|
|
@app.route('/')
|
|
@requires_auth
|
|
def index():
|
|
return redirect(url_for('get_pit_stops'))
|
|
|
|
|
|
@app.route('/pitstops', methods=['POST'])
|
|
@requires_auth
|
|
def create_pit_stop():
|
|
last_pitstop = Pitstop.query.order_by(Pitstop.date.desc()).first()
|
|
if last_pitstop is None:
|
|
last_pitstop = Pitstop(0, 0, None)
|
|
error_msg = {}
|
|
|
|
date_of_pitstop = request.form['date']
|
|
try:
|
|
date_of_pitstop = datetime.strptime(date_of_pitstop, '%Y-%m-%d').strftime('%Y-%m-%d')
|
|
except ValueError:
|
|
error_msg['date'] = 'invalid date, only YYYY-MM-DD is allowed'
|
|
date_of_pitstop = request.form['date']
|
|
|
|
odometer = request.form['odometer']
|
|
try:
|
|
odometer = int(odometer)
|
|
except ValueError:
|
|
error_msg['odometer'] = 'Illegal Value, only Integers allowed'
|
|
odometer = None
|
|
if odometer is not None and odometer <= last_pitstop.odometer:
|
|
error_msg['odometer'] = 'Illegal Value, new Value must be bigger as given value'
|
|
odometer = request.form['odometer']
|
|
if odometer is None:
|
|
odometer = request.form['odometer']
|
|
|
|
litres = request.form['litres']
|
|
try:
|
|
litres = float(litres)
|
|
except ValueError:
|
|
error_msg['litres'] = 'Illegal Value, only floating point allowed'
|
|
litres = None
|
|
if litres is not None and litres <= 0:
|
|
error_msg['litres'] = 'Litres must not be 0'
|
|
litres = request.form['litres']
|
|
if litres is None:
|
|
litres = request.form['litres']
|
|
|
|
# error checking here
|
|
if len(error_msg) > 0:
|
|
data = {'last': {'date': date_of_pitstop, 'odometer': odometer, 'litres': litres}, 'error': error_msg}
|
|
return render_template('newPitStopForm.html', data=data)
|
|
|
|
new_stop = Pitstop(odometer, litres, datetime.strptime(date_of_pitstop, '%Y-%m-%d'))
|
|
sqldb.session.add(new_stop)
|
|
sqldb.session.commit()
|
|
|
|
return redirect(url_for('get_pit_stops'))
|
|
|
|
|
|
@app.route('/pitstops/createForm', methods=['GET'])
|
|
@requires_auth
|
|
def create_pit_stop_form():
|
|
last_stop = Pitstop.query.order_by(Pitstop.date.desc()).first()
|
|
if last_stop is None:
|
|
last_stop = Pitstop(0, 0, date(1970, 1, 1))
|
|
values = dict()
|
|
values['odometer'] = last_stop.odometer
|
|
values['litres'] = last_stop.litres
|
|
values['date'] = time.strftime("%Y-%m-%d")
|
|
g.data['last'] = values
|
|
g.data['error'] = None
|
|
return render_template('newPitStopForm.html', data=g.data)
|
|
|
|
|
|
@app.route('/pitstops', methods=['GET'])
|
|
@requires_auth
|
|
def get_pit_stops():
|
|
data = prepare_pit_stops(Pitstop.query.all())
|
|
g.data['pitstops'] = data
|
|
return render_template('pitstops.html', data=g.data)
|
|
|
|
|
|
@app.route('/manual', methods=['GET'])
|
|
@requires_auth
|
|
def get_manual():
|
|
return render_template('manual.html', data=g.data)
|
|
|
|
|
|
@app.route('/statistics', methods=['GET'])
|
|
@requires_auth
|
|
def get_statistics():
|
|
pitstops = Pitstop.query.all()
|
|
count = len(pitstops)
|
|
distance = 0
|
|
sum_litres = 0
|
|
average_distance = 0
|
|
average_litres_fuelled = 0
|
|
average_litres_used = 0
|
|
|
|
if count > 0:
|
|
sum_litres = 0
|
|
for pitstop in pitstops:
|
|
sum_litres += pitstop.litres
|
|
average_litres_fuelled = sum_litres/count
|
|
if count > 1:
|
|
distance = pitstops[-1].odometer - pitstops[0].odometer
|
|
average_distance = distance/(count - 1)
|
|
average_litres_used = 100 * (sum_litres-pitstops[0].litres)/distance
|
|
g.data['distance'] = distance
|
|
g.data['count'] = count
|
|
g.data['litres'] = sum_litres
|
|
g.data['averageDistance'] = average_distance
|
|
g.data['averageListresFuelled'] = average_litres_fuelled
|
|
g.data['averageListresUsed'] = average_litres_used
|
|
return render_template('statistics.html', data=g.data)
|
|
|
|
|
|
def prepare_pit_stops(pss):
|
|
pitstops = []
|
|
for pitstop_index in range(0, len(pss)):
|
|
p = dict()
|
|
p['odometer'] = pss[pitstop_index].odometer
|
|
p['litres'] = pss[pitstop_index].litres
|
|
p['date'] = pss[pitstop_index].date
|
|
pitstops.append(p)
|
|
for pitstop_index in range(1, len(pitstops)):
|
|
last = pitstops[pitstop_index - 1]
|
|
curr = pitstops[pitstop_index]
|
|
curr['distance'] = curr['odometer'] - last['odometer']
|
|
curr['average'] = 100 * curr['litres']/curr['distance']
|
|
last_date = last['date']
|
|
curr_date = curr['date']
|
|
curr['days'] = (curr_date - last_date).days
|
|
pitstops.reverse()
|
|
return pitstops
|
|
|
|
if __name__ == '__main__':
|
|
app.run(debug=True, host='0.0.0.0')
|