rollerverbrauch/app/main.py

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
from flask.ext.security import Security, SQLAlchemyUserDatastore, \
    UserMixin, RoleMixin, login_required, utils
from flask.ext.security.core import current_user
import uuid
import hashlib
from functools import wraps
from flask_wtf import Form
from wtforms import DateField, IntegerField, DecimalField, SelectField
from wtforms.validators import DataRequired, ValidationError
import os

app = Flask(__name__)
DATABASE = '/data/rollerverbrauch.db'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'+DATABASE
db = SQLAlchemy(app)

app.config['SECRET_KEY'] = 'development key'
app.config['SECURITY_PASSWORD_HASH'] = 'pbkdf2_sha512'
app.config['SECURITY_PASSWORD_SALT'] = 'xxxxxxxxxxxxxxxxxxxxxx'
app.config.from_object(__name__)


roles_users = db.Table('roles_users',
                       db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
                       db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))


class Role(db.Model, RoleMixin):
    id = db.Column(db.Integer(), primary_key=True)
    name = db.Column(db.String(80), unique=True)
    description = db.Column(db.String(255))

    def __str__(self):
        return self.name

    def __hash__(self):
        return hash(self.name)


class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(255), unique=True)
    password = db.Column(db.String(255))
    active = db.Column(db.Boolean())
    confirmed_at = db.Column(db.DateTime())
    vehicles = db.relationship(
        'Vehicle'
    )
    roles = db.relationship(
        'Role',
        secondary=roles_users,
        backref=db.backref('users', lazy='dynamic')
    )

    def __repr__(self):
        return '<User %r>' % self.email


class Vehicle(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    owner_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    name = db.Column(db.String(255), unique=True)
    pitstops = db.relationship(
        'Pitstop'
    )

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return '<Vehicle %r>' % self.name


class Pitstop(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    date = db.Column(db.Date)
    odometer = db.Column(db.Integer)
    litres = db.Column(db.Numeric(5,2))
    vehicle_id = db.Column(db.Integer, db.ForeignKey('vehicle.id'))

    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)


user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)

@app.before_first_request
def before_first_request():
    db.create_all()

    user_datastore.find_or_create_role(name='admin', description='Administrator')
    user_datastore.find_or_create_role(name='end-user', description='End user')

    encrypted_password = utils.encrypt_password('password')
    if not user_datastore.get_user('someone@example.com'):
        user_datastore.create_user(email='someone@example.com', password=encrypted_password)
    if not user_datastore.get_user('admin@example.com'):
        user_datastore.create_user(email='admin@example.com', password=encrypted_password)

    # Commit any database changes; the User and Roles must exist before we can add a Role to the User
    db.session.commit()

    # Give one User has the "end-user" role, while the other has the "admin" role. (This will have no effect if the
    # Users already have these Roles.) Again, commit any database changes.
    user_datastore.add_role_to_user('someone@example.com', 'end-user')
    user_datastore.add_role_to_user('admin@example.com', 'admin')
    db.session.commit()

    user = User.query.filter(User.email=='someone@example.com').first()
    if len(user.vehicles) == 0:
        v = Vehicle('someone')
        db.session.add(v)
        user.vehicles.append(v)
        db.session.commit()

    user = User.query.filter(User.email=='admin@example.com').first()
    if len(user.vehicles) == 0:
        v = Vehicle('admin_1')
        db.session.add(v)
        user.vehicles.append(v)
        v = Vehicle('admin_2')
        db.session.add(v)
        user.vehicles.append(v)
        db.session.commit()


@app.before_request
def before_request():
    g.data = {}


@app.route('/')
@login_required
def index():
    return redirect(url_for('get_pit_stops'))


def date_check(form, field):
    if field.data < form.pitstop.date:
        raise ValidationError('The new date must after %s' % form.pitstop.date)


def odometer_check(form, field):
    if field.data <= form.pitstop.odometer:
        raise ValidationError('The new odometer value must be higher than %i km' % form.pitstop.odometer)


def litres_check(form, field):
    if field.data is not None and field.data <= 0:
        raise ValidationError('You must fuel at least 0.1 l')


class CreatePitstopForm(Form):
    vehicle = SelectField('Vehicle', coerce=int)
    date = DateField('Date of Pitstop', validators=[date_check])
    odometer = IntegerField('Odometer (km)', validators=[odometer_check])
    litres = DecimalField('Litres (l)', places=1, validators=[litres_check])
    pitstop = None

    def set_pitstop(self, pitstop):
        self.pitstop = pitstop


@app.route('/pitstops/createForm', methods=['GET', 'POST'])
@login_required
def create_pit_stop_form():
    last_pitstop = Pitstop.query.order_by(Pitstop.id.desc()).first()
    if last_pitstop is None:
        last_pitstop = Pitstop(0, 0, date.today())

    form = CreatePitstopForm()
    form.set_pitstop(last_pitstop)
    print(current_user.vehicles)

    form.vehicle.choices = [(g.id, g.name) for g in current_user.vehicles]
    if form.validate_on_submit():
        print(form.vehicle.data)
        v = Vehicle.query.filter(Vehicle.id==form.vehicle.data).first()
        new_stop = Pitstop(form.odometer.data, form.litres.data, form.date.data)
        db.session.add(new_stop)
        v.pitstops.append(new_stop)
        db.session.commit()
        return redirect(url_for('get_pit_stops'))

    # dynamically set values
    form.odometer.default = last_pitstop.odometer
    form.litres.default = last_pitstop.litres
    form.date.default = date.today()
    form.process()
    return render_template('newPitStopForm.html', form=form)


@app.route('/pitstops', methods=['GET'])
@login_required
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'])
@login_required
def get_manual():
    return render_template('manual.html', data=g.data)


@app.route('/statistics', methods=['GET'])
@login_required
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__':
    DEBUG = 'DEBUG' in os.environ and os.environ['DEBUG'] != 'False'
    app.run(debug=DEBUG, host='0.0.0.0')