431 lines
15 KiB
Python
431 lines
15 KiB
Python
from datetime import date
|
|
from io import BytesIO
|
|
|
|
import matplotlib.pyplot as plt
|
|
from fastapi import APIRouter, Depends, HTTPException, Response, status
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.api.deps import get_current_telegram_user
|
|
from app.db.session import get_session
|
|
from app.models.car import Car, OdometerHistory
|
|
from app.models.expense import ExpenseEntry, FuelEntry, ServiceEntry
|
|
from app.models.user import User
|
|
from app.schemas.expense import (
|
|
ExpenseEntryCreate,
|
|
ExpenseEntryRead,
|
|
ExpenseEntryUpdate,
|
|
FuelEntryCreate,
|
|
FuelEntryRead,
|
|
FuelEntryUpdate,
|
|
OdometerHistoryRead,
|
|
OdometerPrediction,
|
|
OwnershipStats,
|
|
ServiceEntryCreate,
|
|
ServiceEntryRead,
|
|
ServiceEntryUpdate,
|
|
)
|
|
from app.services.calculations import dataframe_from_query, get_ownership_stats, predict_odometer
|
|
from app.services.odometer import (
|
|
apply_odometer_from_record,
|
|
recalculate_current_odometer,
|
|
validate_odometer_change,
|
|
)
|
|
|
|
router = APIRouter(tags=["entries"])
|
|
|
|
|
|
async def ensure_owned_car(session: AsyncSession, car_id: int, user: User) -> Car:
|
|
car = await session.get(Car, car_id)
|
|
if car is None:
|
|
raise HTTPException(status_code=404, detail="Car not found")
|
|
if car.owner_id != user.id:
|
|
raise HTTPException(status_code=403, detail="Forbidden")
|
|
return car
|
|
|
|
|
|
async def ensure_entry_owner(
|
|
session: AsyncSession, entry: FuelEntry | ServiceEntry | ExpenseEntry | None, user: User
|
|
) -> FuelEntry | ServiceEntry | ExpenseEntry:
|
|
if entry is None:
|
|
raise HTTPException(status_code=404, detail="Entry not found")
|
|
await ensure_owned_car(session, entry.car_id, user)
|
|
return entry
|
|
|
|
|
|
@router.post("/fuel", response_model=FuelEntryRead, status_code=status.HTTP_201_CREATED)
|
|
async def create_fuel_entry(
|
|
payload: FuelEntryCreate,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> FuelEntry:
|
|
car = await ensure_owned_car(session, payload.car_id, current_user)
|
|
validate_odometer_change(
|
|
car,
|
|
payload.odometer,
|
|
source_record_type="fuel",
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
entry = FuelEntry(**payload.model_dump(exclude={"confirm_lower_odometer"}))
|
|
session.add(entry)
|
|
await session.flush()
|
|
await apply_odometer_from_record(
|
|
session,
|
|
car,
|
|
new_odometer=payload.odometer,
|
|
source_record_type="fuel",
|
|
source_record_id=entry.id,
|
|
changed_by=current_user.id,
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
await session.commit()
|
|
await session.refresh(entry)
|
|
return entry
|
|
|
|
|
|
@router.get("/cars/{car_id}/fuel", response_model=list[FuelEntryRead])
|
|
async def list_fuel_entries(
|
|
car_id: int,
|
|
date_from: date | None = None,
|
|
date_to: date | None = None,
|
|
limit: int = 50,
|
|
offset: int = 0,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> list[FuelEntry]:
|
|
await ensure_owned_car(session, car_id, current_user)
|
|
limit = min(max(limit, 1), 200)
|
|
offset = max(offset, 0)
|
|
stmt = select(FuelEntry).where(FuelEntry.car_id == car_id)
|
|
if date_from:
|
|
stmt = stmt.where(FuelEntry.entry_date >= date_from)
|
|
if date_to:
|
|
stmt = stmt.where(FuelEntry.entry_date <= date_to)
|
|
result = await session.execute(
|
|
stmt.order_by(FuelEntry.entry_date.desc()).limit(limit).offset(offset)
|
|
)
|
|
return list(result.scalars())
|
|
|
|
|
|
@router.patch("/fuel/{entry_id}", response_model=FuelEntryRead)
|
|
async def update_fuel_entry(
|
|
entry_id: int,
|
|
payload: FuelEntryUpdate,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> FuelEntry:
|
|
entry = await ensure_entry_owner(session, await session.get(FuelEntry, entry_id), current_user)
|
|
car = await session.get(Car, entry.car_id)
|
|
if car is not None and payload.odometer is not None:
|
|
validate_odometer_change(
|
|
car,
|
|
payload.odometer,
|
|
source_record_type="fuel",
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
for field, value in payload.model_dump(exclude_unset=True, exclude={"confirm_lower_odometer"}).items():
|
|
setattr(entry, field, value)
|
|
if payload.total_cost is None and (
|
|
payload.liters is not None or payload.price_per_liter is not None
|
|
):
|
|
entry.total_cost = entry.liters * entry.price_per_liter
|
|
await recalculate_current_odometer(session, entry.car_id, changed_by=current_user.id, source_record_type="fuel_update")
|
|
await session.commit()
|
|
await session.refresh(entry)
|
|
return entry
|
|
|
|
|
|
@router.delete("/fuel/{entry_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def delete_fuel_entry(
|
|
entry_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> None:
|
|
entry = await ensure_entry_owner(session, await session.get(FuelEntry, entry_id), current_user)
|
|
car_id = entry.car_id
|
|
await session.delete(entry)
|
|
await session.flush()
|
|
await recalculate_current_odometer(session, car_id, changed_by=current_user.id, source_record_type="fuel_delete")
|
|
await session.commit()
|
|
|
|
|
|
@router.post("/service", response_model=ServiceEntryRead, status_code=status.HTTP_201_CREATED)
|
|
async def create_service_entry(
|
|
payload: ServiceEntryCreate,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> ServiceEntry:
|
|
car = await ensure_owned_car(session, payload.car_id, current_user)
|
|
validate_odometer_change(
|
|
car,
|
|
payload.odometer,
|
|
source_record_type="service",
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
entry = ServiceEntry(**payload.model_dump(exclude={"confirm_lower_odometer"}))
|
|
session.add(entry)
|
|
await session.flush()
|
|
await apply_odometer_from_record(
|
|
session,
|
|
car,
|
|
new_odometer=payload.odometer,
|
|
source_record_type="service",
|
|
source_record_id=entry.id,
|
|
changed_by=current_user.id,
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
await session.commit()
|
|
await session.refresh(entry)
|
|
return entry
|
|
|
|
|
|
@router.get("/cars/{car_id}/service", response_model=list[ServiceEntryRead])
|
|
async def list_service_entries(
|
|
car_id: int,
|
|
date_from: date | None = None,
|
|
date_to: date | None = None,
|
|
limit: int = 50,
|
|
offset: int = 0,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> list[ServiceEntry]:
|
|
await ensure_owned_car(session, car_id, current_user)
|
|
limit = min(max(limit, 1), 200)
|
|
offset = max(offset, 0)
|
|
stmt = select(ServiceEntry).where(ServiceEntry.car_id == car_id)
|
|
if date_from:
|
|
stmt = stmt.where(ServiceEntry.entry_date >= date_from)
|
|
if date_to:
|
|
stmt = stmt.where(ServiceEntry.entry_date <= date_to)
|
|
result = await session.execute(
|
|
stmt.order_by(ServiceEntry.entry_date.desc()).limit(limit).offset(offset)
|
|
)
|
|
return list(result.scalars())
|
|
|
|
|
|
@router.patch("/service/{entry_id}", response_model=ServiceEntryRead)
|
|
async def update_service_entry(
|
|
entry_id: int,
|
|
payload: ServiceEntryUpdate,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> ServiceEntry:
|
|
entry = await ensure_entry_owner(session, await session.get(ServiceEntry, entry_id), current_user)
|
|
car = await session.get(Car, entry.car_id)
|
|
if car is not None and payload.odometer is not None:
|
|
validate_odometer_change(
|
|
car,
|
|
payload.odometer,
|
|
source_record_type="service",
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
for field, value in payload.model_dump(exclude_unset=True, exclude={"confirm_lower_odometer"}).items():
|
|
setattr(entry, field, value)
|
|
await recalculate_current_odometer(session, entry.car_id, changed_by=current_user.id, source_record_type="service_update")
|
|
await session.commit()
|
|
await session.refresh(entry)
|
|
return entry
|
|
|
|
|
|
@router.delete("/service/{entry_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def delete_service_entry(
|
|
entry_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> None:
|
|
entry = await ensure_entry_owner(session, await session.get(ServiceEntry, entry_id), current_user)
|
|
car_id = entry.car_id
|
|
await session.delete(entry)
|
|
await session.flush()
|
|
await recalculate_current_odometer(session, car_id, changed_by=current_user.id, source_record_type="service_delete")
|
|
await session.commit()
|
|
|
|
|
|
@router.post("/expenses", response_model=ExpenseEntryRead, status_code=status.HTTP_201_CREATED)
|
|
async def create_expense_entry(
|
|
payload: ExpenseEntryCreate,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> ExpenseEntry:
|
|
car = await ensure_owned_car(session, payload.car_id, current_user)
|
|
validate_odometer_change(
|
|
car,
|
|
payload.odometer,
|
|
source_record_type="expense",
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
entry = ExpenseEntry(**payload.model_dump(exclude={"confirm_lower_odometer"}))
|
|
session.add(entry)
|
|
await session.flush()
|
|
await apply_odometer_from_record(
|
|
session,
|
|
car,
|
|
new_odometer=payload.odometer,
|
|
source_record_type="expense",
|
|
source_record_id=entry.id,
|
|
changed_by=current_user.id,
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
await session.commit()
|
|
await session.refresh(entry)
|
|
return entry
|
|
|
|
|
|
@router.get("/cars/{car_id}/expenses", response_model=list[ExpenseEntryRead])
|
|
async def list_expense_entries(
|
|
car_id: int,
|
|
date_from: date | None = None,
|
|
date_to: date | None = None,
|
|
category: str | None = None,
|
|
limit: int = 50,
|
|
offset: int = 0,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> list[ExpenseEntry]:
|
|
await ensure_owned_car(session, car_id, current_user)
|
|
limit = min(max(limit, 1), 200)
|
|
offset = max(offset, 0)
|
|
stmt = select(ExpenseEntry).where(ExpenseEntry.car_id == car_id)
|
|
if date_from:
|
|
stmt = stmt.where(ExpenseEntry.entry_date >= date_from)
|
|
if date_to:
|
|
stmt = stmt.where(ExpenseEntry.entry_date <= date_to)
|
|
if category:
|
|
stmt = stmt.where(ExpenseEntry.category == category)
|
|
result = await session.execute(
|
|
stmt.order_by(ExpenseEntry.entry_date.desc(), ExpenseEntry.id.desc()).limit(limit).offset(offset)
|
|
)
|
|
return list(result.scalars())
|
|
|
|
|
|
@router.patch("/expenses/{entry_id}", response_model=ExpenseEntryRead)
|
|
async def update_expense_entry(
|
|
entry_id: int,
|
|
payload: ExpenseEntryUpdate,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> ExpenseEntry:
|
|
entry = await ensure_entry_owner(session, await session.get(ExpenseEntry, entry_id), current_user)
|
|
car = await session.get(Car, entry.car_id)
|
|
if car is not None and payload.odometer is not None:
|
|
validate_odometer_change(
|
|
car,
|
|
payload.odometer,
|
|
source_record_type="expense",
|
|
confirm_lower_odometer=payload.confirm_lower_odometer,
|
|
)
|
|
for field, value in payload.model_dump(exclude_unset=True, exclude={"confirm_lower_odometer"}).items():
|
|
setattr(entry, field, value)
|
|
await recalculate_current_odometer(session, entry.car_id, changed_by=current_user.id, source_record_type="expense_update")
|
|
await session.commit()
|
|
await session.refresh(entry)
|
|
return entry
|
|
|
|
|
|
@router.delete("/expenses/{entry_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def delete_expense_entry(
|
|
entry_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> None:
|
|
entry = await ensure_entry_owner(session, await session.get(ExpenseEntry, entry_id), current_user)
|
|
car_id = entry.car_id
|
|
await session.delete(entry)
|
|
await session.flush()
|
|
await recalculate_current_odometer(session, car_id, changed_by=current_user.id, source_record_type="expense_delete")
|
|
await session.commit()
|
|
|
|
|
|
@router.get("/cars/{car_id}/odometer-history", response_model=list[OdometerHistoryRead])
|
|
async def odometer_history(
|
|
car_id: int,
|
|
limit: int = 50,
|
|
offset: int = 0,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> list[OdometerHistory]:
|
|
await ensure_owned_car(session, car_id, current_user)
|
|
limit = min(max(limit, 1), 200)
|
|
result = await session.execute(
|
|
select(OdometerHistory)
|
|
.where(OdometerHistory.car_id == car_id)
|
|
.order_by(OdometerHistory.changed_at.desc(), OdometerHistory.id.desc())
|
|
.limit(limit)
|
|
.offset(max(offset, 0))
|
|
)
|
|
return list(result.scalars())
|
|
|
|
|
|
@router.get("/cars/{car_id}/stats", response_model=OwnershipStats)
|
|
async def car_stats(
|
|
car_id: int,
|
|
date_from: date | None = None,
|
|
date_to: date | None = None,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> OwnershipStats:
|
|
await ensure_owned_car(session, car_id, current_user)
|
|
today = date.today()
|
|
period_from = date_from or today.replace(day=1)
|
|
period_to = date_to or today
|
|
return await get_ownership_stats(session, car_id, period_from, period_to)
|
|
|
|
|
|
@router.get("/cars/{car_id}/analytics", response_model=OdometerPrediction)
|
|
async def car_analytics(
|
|
car_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> OdometerPrediction:
|
|
await ensure_owned_car(session, car_id, current_user)
|
|
return await predict_odometer(session, car_id)
|
|
|
|
|
|
@router.get("/cars/{car_id}/charts/expenses.png")
|
|
async def expenses_chart(
|
|
car_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: User = Depends(get_current_telegram_user),
|
|
) -> Response:
|
|
await ensure_owned_car(session, car_id, current_user)
|
|
fuel_df = await dataframe_from_query(
|
|
session,
|
|
select(FuelEntry.entry_date.label("date"), FuelEntry.total_cost.label("cost")).where(
|
|
FuelEntry.car_id == car_id
|
|
),
|
|
)
|
|
service_df = await dataframe_from_query(
|
|
session,
|
|
select(ServiceEntry.entry_date.label("date"), ServiceEntry.total_cost.label("cost")).where(
|
|
ServiceEntry.car_id == car_id
|
|
),
|
|
)
|
|
if fuel_df.empty and service_df.empty:
|
|
raise HTTPException(status_code=404, detail="No data for chart")
|
|
|
|
frames = []
|
|
if not fuel_df.empty:
|
|
fuel_df["type"] = "fuel"
|
|
frames.append(fuel_df)
|
|
if not service_df.empty:
|
|
service_df["type"] = "service"
|
|
frames.append(service_df)
|
|
|
|
import pandas as pd
|
|
|
|
df = pd.concat(frames)
|
|
df["date"] = pd.to_datetime(df["date"])
|
|
pivot = df.pivot_table(index="date", columns="type", values="cost", aggfunc="sum").sort_index()
|
|
|
|
fig, ax = plt.subplots(figsize=(8, 4.5))
|
|
pivot.plot(kind="bar", stacked=True, ax=ax)
|
|
ax.set_title("Car expenses")
|
|
ax.set_xlabel("Date")
|
|
ax.set_ylabel("Cost")
|
|
fig.tight_layout()
|
|
|
|
buffer = BytesIO()
|
|
fig.savefig(buffer, format="png")
|
|
plt.close(fig)
|
|
return Response(buffer.getvalue(), media_type="image/png")
|