430 lines
14 KiB
Python
430 lines
14 KiB
Python
from datetime import date
|
|
from flask import Flask
|
|
from flask import redirect, g
|
|
from flask import render_template
|
|
from flask import url_for
|
|
from flask.ext.mail import Mail
|
|
from flask.ext.security import Security, SQLAlchemyUserDatastore, \
|
|
UserMixin, RoleMixin, login_required, roles_required
|
|
from flask.ext.security import user_registered
|
|
from flask_security.core import current_user
|
|
from flask_sqlalchemy import SQLAlchemy
|
|
from sqlalchemy.exc import IntegrityError
|
|
from flask.ext.security.forms import LoginForm
|
|
|
|
app = Flask(__name__)
|
|
app.config['SECURITY_PASSWORD_HASH'] = 'pbkdf2_sha512'
|
|
app.config['SECURITY_REGISTERABLE'] = True
|
|
app.config['SECURITY_CHANGEABLE'] = True
|
|
app.config['SECURITY_RECOVERABLE'] = True
|
|
app.config.from_envvar('config')
|
|
app.config.from_object(__name__)
|
|
|
|
db = SQLAlchemy(app)
|
|
mail = Mail(app)
|
|
|
|
import rollerverbrauch.tools as tools
|
|
|
|
from rollerverbrauch.forms import \
|
|
CreatePitstopForm, \
|
|
EditVehicleForm, \
|
|
DeleteVehicleForm, \
|
|
SelectVehicleForm, \
|
|
DeleteAccountForm, \
|
|
DeletePitStopForm, \
|
|
EditPitstopForm, \
|
|
CreateConsumableForm, \
|
|
EditConsumableForm, \
|
|
DeletConsumableForm
|
|
|
|
from rollerverbrauch.entities import \
|
|
User, \
|
|
Role, \
|
|
Pitstop, \
|
|
Vehicle, \
|
|
Consumable
|
|
|
|
# required to activate the filters
|
|
import rollerverbrauch.filters
|
|
|
|
|
|
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
|
|
security = Security(app, user_datastore)
|
|
|
|
|
|
@user_registered.connect_via(app)
|
|
def user_registered_sighandler(app, user, confirm_token):
|
|
"""
|
|
Called after a user was created
|
|
"""
|
|
role = user_datastore.find_role('user')
|
|
user_datastore.add_role_to_user(user, role)
|
|
new_vehicle = Vehicle('default vehicle')
|
|
db.session.add(new_vehicle)
|
|
user.vehicles.append(new_vehicle)
|
|
db.session.commit()
|
|
tools.db_log_add(user)
|
|
tools.db_log_add(new_vehicle)
|
|
|
|
|
|
@app.before_first_request
|
|
def before_first_request():
|
|
db.create_all()
|
|
print("""
|
|
=========================
|
|
TEST
|
|
========================
|
|
""")
|
|
user_datastore.find_or_create_role(name='admin', description='Role for administrators')
|
|
user_datastore.find_or_create_role(name='user', description='Role for all users.')
|
|
db.session.commit()
|
|
|
|
|
|
@app.before_request
|
|
def before_request():
|
|
g.data = {}
|
|
|
|
|
|
@app.route('/')
|
|
def index():
|
|
if current_user.is_authenticated:
|
|
return redirect(url_for('get_pit_stops'))
|
|
else:
|
|
user_count = len(User.query.all())
|
|
vehicles = Vehicle.query.all()
|
|
litres = 0
|
|
kilometers = 0
|
|
for vehicle in vehicles:
|
|
stats = tools.VehicleStats(vehicle)
|
|
litres += stats.overall_litres
|
|
kilometers += stats.overall_distance
|
|
vehicle_count = len(vehicles)
|
|
pitstop_count = len(Pitstop.query.all())
|
|
data = {
|
|
'users':user_count,
|
|
'vehicles': vehicle_count,
|
|
'pitstops': pitstop_count,
|
|
'litres': litres,
|
|
'kilometers': kilometers
|
|
}
|
|
return render_template('index.html', login_user_form=LoginForm(), data=data)
|
|
|
|
|
|
@app.route('/account/vehicle/edit/<int:vid>', methods=['GET', 'POST'])
|
|
@login_required
|
|
def edit_vehicle(vid):
|
|
vehicle = Vehicle.query.filter(Vehicle.id == vid).first()
|
|
|
|
# prevent edit of foreign vehicles
|
|
if vehicle not in current_user.vehicles:
|
|
return redirect(url_for('get_account_page'))
|
|
|
|
form = EditVehicleForm()
|
|
|
|
if form.name.data is not None:
|
|
form.name.default = form.name.data
|
|
|
|
if form.validate_on_submit():
|
|
vehicle.name = form.name.data
|
|
try:
|
|
db.session.commit()
|
|
tools.db_log_update(vehicle)
|
|
except IntegrityError:
|
|
db.session.rollback()
|
|
form.name.errors.append('"%s" is not unique.' % (form.name.data))
|
|
return render_template('editVehicleForm.html', form=form)
|
|
return redirect(url_for('get_account_page'))
|
|
|
|
form.name.default = vehicle.name
|
|
form.process()
|
|
return render_template('editVehicleForm.html', form=form, vehicle=vehicle)
|
|
|
|
|
|
@app.route('/account/vehicle/delete/<int:vid>', methods=['GET', 'POST'])
|
|
@login_required
|
|
def delete_vehicle(vid):
|
|
vehicle = Vehicle.query.filter(Vehicle.id == vid).first()
|
|
|
|
# prevent deletion of foreign vehicles
|
|
if vehicle not in current_user.vehicles:
|
|
return redirect(url_for('get_account_page'))
|
|
|
|
if len(current_user.vehicles) == 1:
|
|
return redirect(url_for('get_account_page'))
|
|
|
|
form = DeleteVehicleForm()
|
|
|
|
if form.validate_on_submit():
|
|
db.session.delete(vehicle)
|
|
db.session.commit()
|
|
tools.db_log_delete(vehicle)
|
|
return redirect(url_for('get_account_page'))
|
|
|
|
return render_template('deleteVehicleForm.html', form=form, vehicle=vehicle)
|
|
|
|
|
|
@app.route('/account/vehicle/create', methods=['GET', 'POST'])
|
|
@login_required
|
|
def create_vehicle():
|
|
form = EditVehicleForm()
|
|
|
|
if form.name.data is not None:
|
|
form.name.default = form.name.data
|
|
|
|
if form.validate_on_submit():
|
|
vehicle_name = form.name.data
|
|
new_vehicle = Vehicle(vehicle_name)
|
|
db.session.add(new_vehicle)
|
|
current_user.vehicles.append(new_vehicle)
|
|
try:
|
|
db.session.commit()
|
|
tools.db_log_add(new_vehicle)
|
|
except IntegrityError:
|
|
db.session.rollback()
|
|
form.name.errors.append('"%s" is not unique.' % (form.name.data))
|
|
return render_template('createVehicleForm.html', form=form)
|
|
return redirect(url_for('get_account_page'))
|
|
|
|
return render_template('createVehicleForm.html', form=form)
|
|
|
|
|
|
@app.route('/pitstops/select_vehicle', methods=['GET', 'POST'])
|
|
@login_required
|
|
def select_vehicle_for_new_pitstop():
|
|
form = SelectVehicleForm()
|
|
form.vehicle.choices = [(g.id, g.name) for g in current_user.vehicles]
|
|
|
|
if form.validate_on_submit():
|
|
vehicle = Vehicle.query.filter(Vehicle.id == form.vehicle.data).first()
|
|
if vehicle not in current_user.vehicles:
|
|
return render_template('selectVehicle.html', form=form)
|
|
|
|
return redirect(url_for('create_pit_stop_form', vid=form.vehicle.data))
|
|
|
|
return render_template('selectVehicle.html', form=form)
|
|
|
|
|
|
@app.route('/pitstops/create/<int:vid>', methods=['GET', 'POST'])
|
|
@login_required
|
|
def create_pit_stop_form(vid):
|
|
vehicle = Vehicle.query.filter(Vehicle.id == vid).first()
|
|
if vehicle not in current_user.vehicles:
|
|
return redirect(url_for('select_vehicle_for_new_pitstop'))
|
|
|
|
if len(vehicle.pitstops) > 0:
|
|
last_pitstop = vehicle.pitstops[-1]
|
|
else:
|
|
last_pitstop = Pitstop(0, 0, date(1970, 1, 1), 0, None)
|
|
|
|
form = CreatePitstopForm()
|
|
form.set_pitstop(last_pitstop)
|
|
|
|
if form.validate_on_submit():
|
|
new_stop = Pitstop(form.odometer.data, form.litres.data, form.date.data, form.costs.data)
|
|
db.session.add(new_stop)
|
|
vehicle.pitstops.append(new_stop)
|
|
db.session.commit()
|
|
tools.db_log_add(new_stop)
|
|
return redirect(url_for('get_pit_stops', _anchor= 'v' + str(vehicle.id)))
|
|
|
|
form.odometer.default = last_pitstop.odometer
|
|
form.litres.default = last_pitstop.litres
|
|
form.date.default = date.today()
|
|
form.costs.default = last_pitstop.costs
|
|
form.process()
|
|
messages = {
|
|
'date': 'Date must be between %s and %s (including).' % (str(last_pitstop.date), str(date.today())),
|
|
'odometer': 'Odometer must be greater than %s km.' % (str(last_pitstop.odometer)),
|
|
'costs': 'Costs must be higher than 0.01 €.'
|
|
}
|
|
return render_template('createPitStopForm.html', form=form, vehicle=vehicle, messages=messages)
|
|
|
|
|
|
@app.route('/pitstops/delete/<int:pid>', methods=['GET', 'POST'])
|
|
@login_required
|
|
def delete_pit_stop_form(pid):
|
|
pitstop = Pitstop.query.filter(Pitstop.id == pid).first()
|
|
if pitstop is None:
|
|
return redirect(url_for('get_pit_stops'))
|
|
vehicle = Vehicle.query.filter(Vehicle.id == pitstop.vehicle_id).first()
|
|
if vehicle not in current_user.vehicles:
|
|
return redirect(url_for('get_pit_stops'))
|
|
|
|
form = DeletePitStopForm()
|
|
if form.validate_on_submit():
|
|
db.session.delete(pitstop)
|
|
db.session.commit()
|
|
tools.db_log_delete(pitstop)
|
|
return redirect(url_for('get_pit_stops', _anchor='v' + str(vehicle.id)))
|
|
|
|
return render_template('deletePitstopForm.html', form=form, pitstop=pitstop )
|
|
|
|
|
|
@app.route('/pitstops/edit/<int:pid>', methods=['GET', 'POST'])
|
|
@login_required
|
|
def edit_pit_stop_form(pid):
|
|
edit_pitstop = Pitstop.query.filter(Pitstop.id == pid).first()
|
|
if edit_pitstop is None:
|
|
return redirect(url_for('get_pit_stops'))
|
|
vehicle = Vehicle.query.filter(Vehicle.id == edit_pitstop.vehicle_id).first()
|
|
if vehicle not in current_user.vehicles:
|
|
return redirect(url_for('get_pit_stops'))
|
|
|
|
last_pitstop_pos = vehicle.pitstops.index(edit_pitstop) - 1
|
|
if last_pitstop_pos > 0:
|
|
last_pitstop = vehicle.pitstops[last_pitstop_pos]
|
|
else:
|
|
last_pitstop = Pitstop(0, 0, date(1970, 1, 1))
|
|
|
|
form = EditPitstopForm()
|
|
form.set_pitstop(last_pitstop)
|
|
|
|
if form.validate_on_submit():
|
|
edit_pitstop.costs = form.costs.data
|
|
edit_pitstop.date = form.date.data
|
|
edit_pitstop.litres = form.litres.data
|
|
edit_pitstop.odometer = form.odometer.data
|
|
db.session.commit()
|
|
tools.db_log_update(edit_pitstop)
|
|
return redirect(url_for('get_pit_stops', _anchor='v' + str(vehicle.id)))
|
|
|
|
form.odometer.default = edit_pitstop.odometer
|
|
form.litres.default = edit_pitstop.litres
|
|
form.date.default = edit_pitstop.date
|
|
form.costs.default = edit_pitstop.costs
|
|
form.process()
|
|
messages = {
|
|
'date': 'Date must be between %s and %s (including).' % (str(last_pitstop.date), str(date.today())),
|
|
'odometer': 'Odometer must be greater than %s km.' % (str(last_pitstop.odometer))
|
|
}
|
|
if edit_pitstop.costs > 0:
|
|
messages['costs'] = 'Costs must be higher than 0.01 €.'
|
|
return render_template('editPitStopForm.html', form=form, vehicle=vehicle, messages=messages)
|
|
|
|
|
|
@app.route('/pitstops', methods=['GET'])
|
|
@login_required
|
|
def get_pit_stops():
|
|
return render_template('pitstops.html', user=current_user)
|
|
|
|
|
|
@app.route('/manual', methods=['GET'])
|
|
@login_required
|
|
def get_manual():
|
|
return render_template('manual.html', data=g.data)
|
|
|
|
|
|
@app.route('/admin', methods=['GET'])
|
|
@roles_required('admin')
|
|
def get_admin_page():
|
|
users = User.query.all()
|
|
consumables = Consumable.query.all()
|
|
for consumable in consumables:
|
|
consumable.in_use = Pitstop.query.filter(Pitstop.consumable_id == consumable.id).count() > 0
|
|
return render_template('admin.html', users=users, consumables=consumables)
|
|
|
|
|
|
@app.route('/admin/consumable/create', methods=['GET', 'POST'])
|
|
@login_required
|
|
def create_consumable():
|
|
form = CreateConsumableForm()
|
|
|
|
# preinitialize the defaults with potentially existing values from a try before
|
|
if form.name.data is not None:
|
|
form.name.default = form.name.data
|
|
if form.unit.data is not None:
|
|
form.unit.default = form.unit.data
|
|
|
|
if form.validate_on_submit():
|
|
new_consumable = Consumable(form.name.data, form.unit.data)
|
|
db.session.add(new_consumable)
|
|
try:
|
|
db.session.commit()
|
|
tools.db_log_add(new_consumable)
|
|
except IntegrityError:
|
|
db.session.rollback()
|
|
form.name.errors.append('"%s" is not unique.' % (form.name.data))
|
|
return render_template('createConsumableForm.html', form=form)
|
|
return redirect(url_for('get_admin_page'))
|
|
|
|
return render_template('createConsumableForm.html', form=form)
|
|
|
|
|
|
@app.route('/admin/consumable/delete/<int:cid>', methods=['GET', 'POST'])
|
|
@login_required
|
|
def delete_consumable(cid):
|
|
consumable = Consumable.query.filter(Consumable.id == cid).first()
|
|
if consumable is None:
|
|
return redirect(url_for('get_admin_page'))
|
|
|
|
form = DeletConsumableForm()
|
|
|
|
if form.validate_on_submit():
|
|
db.session.delete(consumable)
|
|
db.session.commit()
|
|
tools.db_log_delete(consumable)
|
|
return redirect(url_for('get_admin_page'))
|
|
|
|
return render_template('deleteConsumableForm.html', form=form, consumable=consumable)
|
|
|
|
|
|
@app.route('/admin/consumable/edit/<int:cid>', methods=['GET', 'POST'])
|
|
@login_required
|
|
def edit_consumable(cid):
|
|
consumable = Consumable.query.filter(Consumable.id == cid).first()
|
|
if consumable is None:
|
|
return redirect(url_for('get_admin_page'))
|
|
|
|
form = EditConsumableForm()
|
|
|
|
form.name.default = consumable.name
|
|
form.unit.default = consumable.unit
|
|
|
|
# preinitialize the defaults with potentially existing values from a try before
|
|
if form.name.data is not None:
|
|
form.name.default = form.name.data
|
|
if form.unit.data is not None:
|
|
form.unit.default = form.unit.data
|
|
|
|
if form.validate_on_submit():
|
|
consumable.name = form.name.data
|
|
consumable.unit = form.unit.data
|
|
try:
|
|
db.session.commit()
|
|
tools.db_log_update(consumable)
|
|
except IntegrityError:
|
|
db.session.rollback()
|
|
form.name.errors.append('"%s" is not unique.' % (form.name.data))
|
|
return render_template('editConsumableForm.html', form=form)
|
|
return redirect(url_for('get_admin_page'))
|
|
|
|
return render_template('editConsumableForm.html', form=form)
|
|
|
|
|
|
@app.route('/account', methods=['GET'])
|
|
@login_required
|
|
def get_account_page():
|
|
return render_template('account.html', data=g.data)
|
|
|
|
|
|
@app.route('/statistics', methods=['GET'])
|
|
@login_required
|
|
def get_statistics():
|
|
stats = []
|
|
for vehicle in current_user.vehicles:
|
|
stats.append(tools.VehicleStats(vehicle))
|
|
return render_template('statistics.html', data=stats)
|
|
|
|
|
|
@app.route('/account/delete', methods=['GET', 'POST'])
|
|
@login_required
|
|
def delete_account():
|
|
form = DeleteAccountForm()
|
|
|
|
if form.validate_on_submit():
|
|
user_datastore.delete_user(current_user)
|
|
db.session.commit()
|
|
return redirect(url_for('index'))
|
|
|
|
return render_template('deleteAccountForm.html', form=form)
|