183 lines
6.4 KiB
Python
183 lines
6.4 KiB
Python
import logging
|
|
from datetime import date
|
|
|
|
from .entities import Pitstop
|
|
|
|
|
|
class ConsumableStats:
|
|
def __init__(self, vehicle, consumable):
|
|
self.name = consumable.name
|
|
self.id = consumable.id
|
|
self.unit = consumable.unit
|
|
self.overall_amount = 0
|
|
self.average_distance = 0
|
|
self.average_amount_fuelled = 0
|
|
self.average_amount_used = 0
|
|
self.average_amount = []
|
|
self.amounts = []
|
|
|
|
pitstops = [stop for stop in vehicle.pitstops if stop.consumable_id == consumable.id]
|
|
pitstop_count = len(pitstops)
|
|
|
|
if pitstop_count > 0:
|
|
for pitstop in pitstops:
|
|
self.overall_amount += pitstop.amount
|
|
self.amounts.append(StatsEvent(pitstop.date, pitstop.amount))
|
|
self.average_amount_fuelled = self.overall_amount / pitstop_count
|
|
if pitstop_count > 1:
|
|
overall_distance = vehicle.pitstops[-1].odometer - vehicle.pitstops[0].odometer
|
|
self.average_distance = overall_distance / (pitstop_count - 1)
|
|
self.average_amount_used = 100 * (self.overall_amount - pitstops[0].amount) / overall_distance
|
|
for index in range(1, pitstop_count):
|
|
last_ps = pitstops[index - 1]
|
|
current_ps = pitstops[index]
|
|
self.average_amount.append(
|
|
StatsEvent(
|
|
current_ps.date,
|
|
round(100 * current_ps.amount/(current_ps.odometer - last_ps.odometer), 2)))
|
|
|
|
|
|
class VehicleStats:
|
|
def __init__(self, vehicle):
|
|
self.name = vehicle.name
|
|
self.id = vehicle.id
|
|
self.overall_distance = 0
|
|
self.overall_costs = 0
|
|
self.consumables = []
|
|
self.odometers = []
|
|
|
|
for consumable in vehicle.consumables:
|
|
self.consumables.append(ConsumableStats(vehicle, consumable))
|
|
|
|
pitstop_count = len(vehicle.pitstops)
|
|
|
|
if pitstop_count > 0:
|
|
for pitstop in vehicle.pitstops:
|
|
self.odometers.append(StatsEvent(pitstop.date, pitstop.odometer))
|
|
if pitstop.costs is not None:
|
|
self.overall_costs += pitstop.costs
|
|
|
|
if pitstop_count > 1:
|
|
self.overall_distance = vehicle.pitstops[-1].odometer - vehicle.pitstops[0].odometer
|
|
|
|
|
|
class StatsEvent:
|
|
def __init__(self, date, value):
|
|
self.date = date
|
|
self.value = value
|
|
|
|
|
|
def db_log_add(entity):
|
|
logging.info('db_add: %s' % str(entity))
|
|
|
|
|
|
def db_log_delete(entity):
|
|
logging.info('db_delete: %s' % str(entity))
|
|
|
|
|
|
def db_log_update(entity):
|
|
logging.info('db_update: %s' % str(entity))
|
|
|
|
|
|
def check_vehicle_name_is_unique(current_user, name_field):
|
|
"""
|
|
Checks if the vehicle name given in the name_field is unique for the vehicles of the current user. An error is added
|
|
to the field it the name is not unique.
|
|
|
|
:param current_user: the user currently logged in
|
|
:param name_field: the form field to enter the name to
|
|
:return: True if the name is unique, False otherwise.
|
|
"""
|
|
vehicle_name = name_field.data
|
|
for vehicle in current_user.vehicles:
|
|
if vehicle.name == vehicle_name:
|
|
name_field.default = vehicle_name
|
|
name_field.errors.append('Vehicle "%s" already exists.' % vehicle_name)
|
|
return False
|
|
return True
|
|
|
|
|
|
def get_latest_pitstop_for_vehicle(vehicle_id):
|
|
"""
|
|
return the latest pit stop for the vehicle with the given id.
|
|
:param vehicle_id: the id of the vehicle
|
|
:return: the latest pitstop or None if no pitstop exists
|
|
"""
|
|
latest_pitstop = Pitstop.query\
|
|
.filter(Pitstop.vehicle_id == vehicle_id)\
|
|
.order_by(Pitstop.id.desc())\
|
|
.first()
|
|
return latest_pitstop
|
|
|
|
|
|
def get_latest_pitstop_for_vehicle_and_consumable(vehicle_id, consumable_id):
|
|
"""
|
|
return the latest pit stop for the vehicle and consumable with the given ids.
|
|
:param vehicle_id: the id of the vehicle
|
|
:param consumable_id: the id of the consumable
|
|
:return: the latest pitstop or None if no pitstop exists
|
|
"""
|
|
latest_pitstop_consumable = Pitstop.query\
|
|
.filter(Pitstop.vehicle_id == vehicle_id)\
|
|
.filter(Pitstop.consumable_id == consumable_id)\
|
|
.order_by(Pitstop.id.desc())\
|
|
.first()
|
|
return latest_pitstop_consumable
|
|
|
|
|
|
def compute_lower_limits_for_new_pitstop(latest_pitstop, last_pitstop_consumable, consumable_id):
|
|
"""
|
|
This function figures out the lower limits for date and odometer of a new pitstop.
|
|
:param latest_pitstop:
|
|
:param last_pitstop_consumable:
|
|
:param consumable_id:
|
|
:return:
|
|
"""
|
|
odometer = 0
|
|
date_of_pitstop = date(1970, 1, 1)
|
|
amount = 0
|
|
costs = 0
|
|
|
|
if latest_pitstop is not None:
|
|
odometer = latest_pitstop.odometer
|
|
date_of_pitstop = latest_pitstop.date
|
|
|
|
if last_pitstop_consumable is not None:
|
|
amount = last_pitstop_consumable.amount
|
|
costs = last_pitstop_consumable.costs
|
|
|
|
return Pitstop(odometer, amount, date_of_pitstop, costs, consumable_id)
|
|
|
|
|
|
# if latest_pitstop is not None:
|
|
# if last_pitstop_consumable is not None and last_pitstop_consumable != latest_pitstop:
|
|
# if latest_pitstop.id > last_pitstop_consumable.id:
|
|
# return Pitstop(latest_pitstop.odometer,
|
|
# last_pitstop_consumable.overall_amount,
|
|
# latest_pitstop.date,
|
|
# last_pitstop_consumable.costs,
|
|
# consumable_id)
|
|
# else:
|
|
# return Pitstop(last_pitstop_consumable.odometer,
|
|
# last_pitstop_consumable.overall_amount,
|
|
# last_pitstop_consumable.date,
|
|
# last_pitstop_consumable.costs,
|
|
# consumable_id)
|
|
# else:
|
|
# # either only one pitstop exists or both are the same
|
|
# litres = 0
|
|
# costs = 0
|
|
# if latest_pitstop.consumable_id == last_pitstop_consumable.consumable_id:
|
|
# litres = latest_pitstop.overall_amount
|
|
# costs = latest_pitstop.costs
|
|
# return Pitstop(latest_pitstop.odometer, litres, latest_pitstop.date, costs, consumable_id)
|
|
# else:
|
|
# # No existing pitstop at all: insert fake data
|
|
# return Pitstop(0, 0, date(1970, 1, 1), 0, None)
|
|
|
|
|
|
def pitstop_service_key(x):
|
|
return x.odometer, x.date
|
|
|
|
|