def put(self, id_: str):
"""
Updates a maintenance work.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
maintenance_work = MaintenanceModel.query.filter(MaintenanceModel.maintenance_id == id_).one()
if inserted_data.get('bike_id', 'ParameterNotInPayload') != 'ParameterNotInPayload':
maintenance_work.bike_id = inserted_data.get('bike_id')
if inserted_data.get('category', 'ParameterNotInPayload') != 'ParameterNotInPayload':
maintenance_work.category = inserted_data.get('category')
if inserted_data.get('name', 'ParameterNotInPayload') != 'ParameterNotInPayload':
maintenance_work.name = inserted_data.get('name')
if inserted_data.get('interval_amount', 'ParameterNotInPayload') != 'ParameterNotInPayload':
maintenance_work.interval_amount = inserted_data.get('interval_amount')
if inserted_data.get('interval_unit', 'ParameterNotInPayload') != 'ParameterNotInPayload':
maintenance_work.interval_unit = inserted_data.get('interval_unit')
if inserted_data.get('interval_type', 'ParameterNotInPayload') != 'ParameterNotInPayload':
maintenance_work.interval_type = inserted_data.get('interval_type')
if inserted_data.get('tags_default', 'ParameterNotInPayload') != 'ParameterNotInPayload':
maintenance_work.tags_default = inserted_data.get('tags_default')
db.session.add(maintenance_work)
db.session.commit()
return None, 204
def put(self, id_: str):
"""
Updates a training history entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
training_entry = TrainingModel.query.filter(
TrainingModel.training_id == id_).one()
if inserted_data.get(
'location',
'ParameterNotInPayload') != 'ParameterNotInPayload':
training_entry.location = inserted_data.get('location')
if inserted_data.get(
'weather_hourly',
'ParameterNotInPayload') != 'ParameterNotInPayload':
training_entry.weather_hourly = inserted_data.get('weather_hourly')
if inserted_data.get(
'datetime_display',
'ParameterNotInPayload') != 'ParameterNotInPayload':
training_entry.datetime_display = datetime.fromtimestamp(
inserted_data.get('datetime_display'),
tz=timezone.utc).replace(tzinfo=None)
db.session.add(training_entry)
db.session.commit()
return None, 204
def get(self, id_: str):
"""
Returns a training history entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
training_entry = TrainingModel.query.filter(
TrainingModel.training_id == id_).one()
training_data = training_schema.dump(training_entry)
setup_data = setup_schema.dump(training_entry.setups, many=True)
training_data['setups'] = []
if len(setup_data) > 0:
for setup_entry in setup_data:
session_data = SessionModel.query.filter(
SessionModel.setup_id == setup_entry['setup_id']).all()
setup_entry['sessions'] = []
if len(session_data) > 0:
for session_entry in session_data:
session = session_schema.dump(session_entry)
session['laptimes'] = laptime_schema.dump(
session_entry.laptimes, many=True)
setup_entry['sessions'].append(session)
training_data['setups'].append(setup_entry)
response = jsonify(training_data)
response.status_code = 200
return response
def put(self, id_: str):
"""
Updates a spare part item parent.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
sparepart = SparepartModel.query.filter(
SparepartModel.sparepart_id == id_).one()
if inserted_data.get(
'name', 'ParameterNotInPayload') != 'ParameterNotInPayload':
sparepart.name = inserted_data.get('name')
if inserted_data.get(
'module', 'ParameterNotInPayload') != 'ParameterNotInPayload':
sparepart.module = inserted_data.get('module')
if inserted_data.get(
'min_stock',
'ParameterNotInPayload') != 'ParameterNotInPayload':
sparepart.min_stock = inserted_data.get('min_stock')
db.session.add(sparepart)
db.session.commit()
return None, 204
def post(self):
"""
Adds a lap time entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
new_laptime = LaptimeModel(
session_id=inserted_data.get('session_id'),
lap_no=inserted_data.get('lap_no'),
valid=inserted_data.get('valid'),
track_layout=inserted_data.get('track_layout'),
laptime_seconds=inserted_data.get('laptime_seconds'),
sectors=inserted_data.get('sectors'),
datetime_display=datetime.fromtimestamp(
inserted_data.get('datetime_display'),
tz=timezone.utc).replace(tzinfo=None),
)
db.session.add(new_laptime)
db.session.commit()
response = jsonify(new_laptime.lap_id)
response.status_code = 201
return response
def post(self):
"""
Adds a training session entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
new_session = SessionModel(
training_id=inserted_data.get('training_id'),
bike_id=inserted_data.get('bike_id'),
setup_id=inserted_data.get('setup_id'),
application=inserted_data.get('application'),
datetime_display=datetime.fromtimestamp(
inserted_data.get('datetime_display'),
tz=timezone.utc).replace(tzinfo=None),
)
db.session.add(new_session)
db.session.commit()
response = jsonify(new_session.session_id)
response.status_code = 201
return response
def get(self):
"""
Returns a list of all training session entries.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
session_all_entries = SessionModel.query.order_by(
SessionModel.datetime_display.desc()).all()
session_entry_list = []
for session_entry in session_all_entries:
laptime_data = laptime_schema.dump(session_entry.laptimes,
many=True)
session_data = session_schema.dump(session_entry)
session_data['laptimes'] = []
if len(laptime_data) > 0:
for laptime_entry in laptime_data:
session_data['laptimes'].append(laptime_entry)
session_entry_list.append(session_data)
response = jsonify(session_entry_list)
response.status_code = 200
return response
def post(self):
"""
Adds a training history entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
new_training = TrainingModel(
location=inserted_data.get('location'),
weather_hourly=inserted_data.get('weather_hourly'),
datetime_display=datetime.fromtimestamp(
inserted_data.get('datetime_display'),
tz=timezone.utc).replace(tzinfo=None),
)
db.session.add(new_training)
db.session.commit()
response = jsonify(new_training.training_id)
response.status_code = 201
return response
def get(self):
"""
Returns a list of all spare parts.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
sparepart_all_entries = SparepartModel.query.order_by(
SparepartModel.datetime_display.desc()).all()
sparepart_entry_list = []
for sparepart_entry in sparepart_all_entries:
sparepartitem_data = sparepartitem_schema.dump(
sparepart_entry.items, many=True)
sparepart_data = sparepart_schema.dump(sparepart_entry)
sparepart_data['current_stock'] = sparepart_entry.current_stock
sparepart_data['items'] = sparepartitem_data
sparepart_entry_list.append(sparepart_data)
response = jsonify(sparepart_entry_list)
response.status_code = 200
return response
def post(self):
"""
Adds a maintenance history entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
new_history = HistoryModel(
maintenance_id=inserted_data.get('maintenance_id'),
bike_id=inserted_data.get('bike_id'),
operating_hours=inserted_data.get('operating_hours'),
comment=inserted_data.get('comment'),
tags=inserted_data.get('tags'),
datetime_display=datetime.fromtimestamp(
inserted_data.get('datetime_display'),
tz=timezone.utc).replace(tzinfo=None),
)
db.session.add(new_history)
db.session.commit()
response = jsonify(new_history.history_id)
response.status_code = 201
return response
def post(self):
"""
Adds a tire entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
new_tire = TireModel(
bike_id=inserted_data.get('bike_id'),
active=inserted_data.get('active'),
rim=inserted_data.get('rim'),
category=inserted_data.get('category'),
manufacturer=inserted_data.get('manufacturer'),
name=inserted_data.get('name'),
compound=inserted_data.get('compound'),
axis=inserted_data.get('axis'),
dimension=inserted_data.get('dimension'),
dot=inserted_data.get('dot'),
condition=inserted_data.get('condition'),
operating_hours=inserted_data.get('operating_hours'),
comment=inserted_data.get('comment'),
)
db.session.add(new_tire)
db.session.commit()
response = jsonify(new_tire.tire_id)
response.status_code = 201
return response
def put(self, id_: str):
"""
Updates a coach advice.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
coach_entry = CoachModel.query.filter(CoachModel.coach_id == id_).one()
if inserted_data.get('category', 'ParameterNotInPayload') != 'ParameterNotInPayload':
coach_entry.category = inserted_data.get('category')
if inserted_data.get('symptom', 'ParameterNotInPayload') != 'ParameterNotInPayload':
coach_entry.symptom = inserted_data.get('symptom')
if inserted_data.get('notes', 'ParameterNotInPayload') != 'ParameterNotInPayload':
coach_entry.notes = inserted_data.get('notes')
if inserted_data.get('questions', 'ParameterNotInPayload') != 'ParameterNotInPayload':
coach_entry.questions = inserted_data.get('questions')
if inserted_data.get('advice', 'ParameterNotInPayload') != 'ParameterNotInPayload':
coach_entry.advice = inserted_data.get('advice')
db.session.add(coach_entry)
db.session.commit()
return None, 204
def post(self):
"""
Creates a new maintenance work.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
new_maintenance = MaintenanceModel(
bike_id=inserted_data.get('bike_id'),
category=inserted_data.get('category'),
name=inserted_data.get('name'),
interval_amount=inserted_data.get('interval_amount'),
interval_unit=inserted_data.get('interval_unit'),
interval_type=inserted_data.get('interval_type'),
tags_default=inserted_data.get('tags_default'),
)
db.session.add(new_maintenance)
db.session.commit()
response = jsonify(new_maintenance.maintenance_id)
response.status_code = 201
return response
def get(self, id_: str):
"""
Returns the number of maintenance warnings.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
maintenance_query = MaintenanceModel.query.filter_by(**{'bike_id': id_}).all()
bike_query = BikeModel.query.filter_by(**{'bike_id': id_}).all()
bike_operating_hours = bike_schema.dump(bike_query, many=True)[0]['operating_hours']
warnings = {
'warnings': 0,
'overdue_maintenance': [],
}
for maintenance_entry in maintenance_query:
maintenance_data = maintenance_schema.dump(maintenance_entry)
history_data = history_schema.dump(maintenance_entry.history, many=True)
if len(history_data) > 0:
state = maintenance_state(maintenance_data, history_data, bike_operating_hours)
if state['absolute'] and state['absolute'] <= 0:
warnings['warnings'] += 1
warnings['overdue_maintenance'].append({**maintenance_data, **history_data[0]})
response = jsonify(warnings)
response.status_code = 200
return response
def post(self):
"""
Adds a training history entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
new_setup = SetupModel(
training_id=inserted_data.get('training_id'),
bike_id=inserted_data.get('bike_id'),
operating_hours=inserted_data.get('operating_hours'),
weather_current=inserted_data.get('weather_current'),
slick_pressure_front=inserted_data.get('slick_pressure_front'),
slick_pressure_rear=inserted_data.get('slick_pressure_rear'),
rain_pressure_front=inserted_data.get('rain_pressure_front'),
rain_pressure_rear=inserted_data.get('rain_pressure_rear'),
setup=inserted_data.get('setup'),
comment=inserted_data.get('comment'),
datetime_display=datetime.fromtimestamp(
inserted_data.get('datetime_display'), tz=timezone.utc).replace(tzinfo=None),
)
db.session.add(new_setup)
db.session.commit()
response = jsonify(new_setup.setup_id)
response.status_code = 201
return response
def post(self):
"""
Adds a coach advice.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
inserted_data = request.get_json()
new_coach = CoachModel(
category=inserted_data.get('category'),
symptom=inserted_data.get('symptom'),
notes=inserted_data.get('notes'),
questions=inserted_data.get('questions'),
advice=inserted_data.get('advice'),
)
db.session.add(new_coach)
db.session.commit()
response = jsonify(new_coach.coach_id)
response.status_code = 201
return response
def get(self):
"""
Returns the number of spoare part warnings.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
sparepart_all_entries = SparepartModel.query.order_by(
SparepartModel.datetime_display.desc()).all()
warnings = {
'warnings': 0,
'missing_spareparts': [],
}
for sparepart_entry in sparepart_all_entries:
if sparepart_entry.current_stock is None or sparepart_entry.min_stock is None:
continue
if sparepart_entry.current_stock < sparepart_entry.min_stock:
sparepartitem_data = sparepartitem_schema.dump(
sparepart_entry.items, many=True)
sparepart_data = sparepart_schema.dump(sparepart_entry)
sparepart_data['current_stock'] = sparepart_entry.current_stock
sparepart_data['items'] = sparepartitem_data
warnings['warnings'] += 1
warnings['missing_spareparts'].append(sparepart_data)
response = jsonify(warnings)
response.status_code = 200
return response
def post(self):
"""
Creates a filtered query based on the input json file and returns the requested data.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
requested = request.get_json()
valid_keys = ["bike_id", "category", "name", "interval_unit", "interval_type", "interval_amount",
"tags_default"]
if not all(x in valid_keys for x in requested.keys()):
response = jsonify([])
response.status_code = 404
return response
filter_by_data = {
'bike_id': requested.get('bike_id'),
'category': requested.get('category'),
'name': requested.get('name'),
'interval_unit': requested.get('interval_unit'),
'interval_type': requested.get('interval_type'),
}
filter_by_data = {key: value for (key, value) in filter_by_data.items() if value is not None}
maintenance_query = MaintenanceModel.query.filter_by(**filter_by_data)
maintenance_query = query_intervals(filter_keys=[
"interval_amount",
], query=maintenance_query, request=requested, model=MaintenanceModel)
bike_operating_hours = None
if requested.get('bike_id', 'ParameterNotInPayload') != 'ParameterNotInPayload':
bike_query = BikeModel.query.filter_by(**{'bike_id': requested.get('bike_id')}).all()
bike_operating_hours = bike_schema.dump(bike_query, many=True)[0]['operating_hours']
if requested.get('tags_default', 'ParameterNotInPayload') != 'ParameterNotInPayload':
maintenance_query = maintenance_query \
.filter(MaintenanceModel.tags_default.contains(cast(requested.get('tags_default'), ARRAY(db.String))))
maintenance_query = maintenance_query \
.order_by(MaintenanceModel.category.asc()) \
.order_by(MaintenanceModel.name.asc()) \
.order_by(MaintenanceModel.interval_type.asc()) \
.order_by(MaintenanceModel.interval_unit.asc()) \
.order_by(MaintenanceModel.interval_amount.asc()) \
.all()
maintenance_categories_dict = query_to_list(maintenance_query=maintenance_query,
bike_operating_hours=bike_operating_hours,
bike_id=requested.get('bike_id'))
response = jsonify(maintenance_categories_dict)
response.status_code = 200
return response
def post(self):
"""
Creates a filtered query based on the input json file and returns the requested data.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
requested = request.get_json()
valid_keys = ["bike_id", "name", "module", "min_stock"]
if not all(x in valid_keys for x in requested.keys()):
response = jsonify([])
response.status_code = 404
return response
filter_by_data = {
'bike_id': requested.get('bike_id'),
'name': requested.get('name'),
'module': requested.get('module'),
}
filter_by_data = {
key: value
for (key, value) in filter_by_data.items() if value is not None
}
sparepart_query = SparepartModel.query.filter_by(**filter_by_data)
sparepart_query = query_intervals(filter_keys=[
"min_stock",
],
query=sparepart_query,
request=requested,
model=SparepartModel)
sparepart_query = sparepart_query \
.order_by(SparepartModel.module.asc()) \
.order_by(SparepartModel.name.asc()) \
.order_by(SparepartModel.min_stock.asc()) \
.all()
sparepart_entry_list = []
for sparepart_entry in sparepart_query:
sparepartitem_data = sparepartitem_schema.dump(
sparepart_entry.items, many=True)
sparepart_data = sparepart_schema.dump(sparepart_entry)
sparepart_data['current_stock'] = sparepart_entry.current_stock
sparepart_data['items'] = sparepartitem_data
sparepart_entry_list.append(sparepart_data)
response = jsonify(sparepart_entry_list)
response.status_code = 200
return response
def post(self):
"""
Returns a list of all tire entries that match the query.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
requested = request.get_json()
valid_keys = [
"bike_id", "active", "category", "axis", "datetime_created",
"datetime_last_modified", "operating_hours"
]
if not all(x in valid_keys for x in requested.keys()):
response = jsonify([])
response.status_code = 404
return response
filter_by_data = {
'bike_id': requested.get('bike_id'),
'active': requested.get('active'),
'category': requested.get('category'),
'axis': requested.get('axis'),
}
filter_by_data = {
key: value
for (key, value) in filter_by_data.items() if value is not None
}
tire_query = TireModel.query.filter_by(**filter_by_data)
tire_query = query_intervals(filter_keys=[
"datetime_created", "datetime_last_modified", "operating_hours"
],
query=tire_query,
request=requested,
model=TireModel)
tire_query = tire_query \
.order_by(TireModel.operating_hours.asc()) \
.order_by(TireModel.dot.asc()) \
.all()
tire_entry_list = []
for tire_entry in tire_query:
tire_data = tire_schema.dump(tire_entry)
tire_entry_list.append(tire_data)
response = jsonify(tire_entry_list)
response.status_code = 200
return response
def delete(self, id_: str):
"""
Deletes a coach advice.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
coach_entry = CoachModel.query.filter(CoachModel.coach_id == id_).one()
db.session.delete(coach_entry)
db.session.commit()
return None, 204
def get(self, id_: str):
"""
Returns a maintenance work.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
maintenance_work = MaintenanceModel.query.filter(MaintenanceModel.maintenance_id == id_).one()
response = jsonify(maintenance_schema.dump(maintenance_work))
response.status_code = 200
return response
def delete(self, id_: str):
"""
Deletes maintenance work.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
maintenance_work = MaintenanceModel.query.filter(MaintenanceModel.maintenance_id == id_).one()
db.session.delete(maintenance_work)
db.session.commit()
return None, 204
def delete(self, id_: str):
"""
Deletes a tire entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
tire_entry = TireModel.query.filter(TireModel.tire_id == id_).one()
db.session.delete(tire_entry)
db.session.commit()
return None, 204
def delete(self, id_: str):
"""
Deletes a training history entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
setup_entry = SetupModel.query.filter(SetupModel.setup_id == id_).one()
db.session.delete(setup_entry)
db.session.commit()
return None, 204
def get(self, id_: str):
"""
Returns a spare part item parent.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
sparepart_item = SparepartModel.query.filter(
SparepartModel.sparepart_id == id_).one()
response = jsonify(sparepart_schema.dump(sparepart_item))
response.status_code = 200
return response
def delete(self, id_: str):
"""
Deletes a spare part item parent.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
sparepart = SparepartModel.query.filter(
SparepartModel.sparepart_id == id_).one()
db.session.delete(sparepart)
db.session.commit()
return None, 204
def delete(self, id_: str):
"""
Deletes a maintenance history entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
history_entry = HistoryModel.query.filter(
HistoryModel.history_id == id_).one()
db.session.delete(history_entry)
db.session.commit()
return None, 204
def get(self, id_: str):
"""
Returns a tire entry.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
tire_entry = TireModel.query.filter(TireModel.tire_id == id_).one()
tire_data = tire_schema.dump(tire_entry)
response = jsonify(tire_data)
response.status_code = 200
return response
def get(self, id_: str):
"""
Returns a coach advice.
"""
api_key = request.headers.get('apikey')
if validate_api_key(api_key).status_code != 200:
return validate_api_key(api_key)
coach_entry = CoachModel.query.filter(CoachModel.coach_id == id_).one()
coach_data = coach_schema.dump(coach_entry)
response = jsonify(coach_data)
response.status_code = 200
return response
