114 lines
4.8 KiB
Python
114 lines
4.8 KiB
Python
from fastapi import APIRouter, HTTPException, Depends
|
|
from sqlalchemy.orm import Session
|
|
from typing import List
|
|
from app.models import Dewar as DewarModel, Slot as SlotModel, LogisticsEvent as LogisticsEventModel
|
|
from app.schemas import LogisticsEventCreate, Slot as SlotSchema, Dewar as DewarSchema
|
|
from app.database import get_db
|
|
import logging
|
|
from datetime import datetime, timedelta
|
|
|
|
router = APIRouter()
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
def calculate_time_until_refill(last_refill: datetime) -> int:
|
|
refill_interval = timedelta(hours=24) # Example interval
|
|
now = datetime.now()
|
|
time_until_next_refill = last_refill + refill_interval - now
|
|
return int(time_until_next_refill.total_seconds())
|
|
|
|
@router.get("/slots", response_model=List[SlotSchema])
|
|
async def get_all_slots(db: Session = Depends(get_db)):
|
|
slots = db.query(SlotModel).all()
|
|
slots_with_refill_time = []
|
|
for slot in slots:
|
|
slot_data = SlotSchema(
|
|
id=slot.id,
|
|
qr_code=slot.qr_code,
|
|
label=slot.label,
|
|
qr_base=slot.qr_base,
|
|
occupied=slot.occupied,
|
|
needs_refill=slot.needs_refill,
|
|
last_refill=slot.last_refill,
|
|
time_until_refill=calculate_time_until_refill(slot.last_refill),
|
|
dewar_unique_id=slot.dewar_unique_id,
|
|
dewar_name=slot.dewar.dewar_name if slot.dewar else None
|
|
)
|
|
slots_with_refill_time.append(slot_data)
|
|
return slots_with_refill_time
|
|
|
|
@router.get("/dewars", response_model=List[DewarSchema])
|
|
async def get_all_dewars(db: Session = Depends(get_db)):
|
|
dewars = db.query(DewarModel).all()
|
|
return dewars
|
|
|
|
@router.get("/dewar/{unique_id}", response_model=DewarSchema)
|
|
async def get_dewar_by_unique_id(unique_id: str, db: Session = Depends(get_db)):
|
|
logger.info(f"Received request for dewar with unique_id: {unique_id}")
|
|
dewar = db.query(DewarModel).filter(DewarModel.unique_id == unique_id.strip()).first()
|
|
if not dewar:
|
|
logger.warning(f"Dewar with unique_id '{unique_id}' not found.")
|
|
raise HTTPException(status_code=404, detail="Dewar not found")
|
|
logger.info(f"Returning dewar: {dewar}")
|
|
return dewar
|
|
|
|
@router.post("/dewar/scan", response_model=dict)
|
|
async def scan_dewar(event_data: LogisticsEventCreate, db: Session = Depends(get_db)):
|
|
dewar_qr_code = event_data.dewar_qr_code
|
|
location_qr_code = event_data.location_qr_code
|
|
transaction_type = event_data.transaction_type
|
|
|
|
print(f"Scanning dewar {dewar_qr_code} for slot {location_qr_code} with transaction type {transaction_type}")
|
|
|
|
dewar = db.query(DewarModel).filter(DewarModel.unique_id == dewar_qr_code).first()
|
|
if not dewar:
|
|
raise HTTPException(status_code=404, detail="Dewar not found")
|
|
|
|
slot = db.query(SlotModel).filter(SlotModel.qr_code == location_qr_code).first()
|
|
|
|
if transaction_type == 'incoming':
|
|
if not slot or slot.occupied:
|
|
raise HTTPException(status_code=400, detail="Slot not found or already occupied")
|
|
print(f"Associating dewar {dewar.unique_id} with slot {slot.qr_code}")
|
|
slot.dewar_unique_id = dewar.unique_id # Properly associate with the unique_id
|
|
slot.occupied = True
|
|
elif transaction_type == 'outgoing':
|
|
if not slot or not slot.occupied or slot.dewar_unique_id != dewar.unique_id:
|
|
raise HTTPException(status_code=400, detail="Slot not found or dewar not associated with slot")
|
|
print(f"Disassociating dewar {dewar.unique_id} from slot {slot.qr_code}")
|
|
slot.dewar_unique_id = None # Remove the association
|
|
slot.occupied = False
|
|
|
|
log_event(db, dewar.id, slot.id if slot else None, transaction_type)
|
|
db.commit()
|
|
return {"message": "Status updated successfully"}
|
|
|
|
def log_event(db: Session, dewar_id: int, slot_id: int, event_type: str):
|
|
new_event = LogisticsEventModel(dewar_id=dewar_id, slot_id=slot_id, event_type=event_type)
|
|
db.add(new_event)
|
|
db.commit()
|
|
|
|
|
|
@router.post("/dewar/refill", response_model=dict)
|
|
async def refill_dewar(qr_code: str, db: Session = Depends(get_db)):
|
|
dewar = db.query(DewarModel).filter(DewarModel.unique_id == qr_code).first()
|
|
if not dewar:
|
|
raise HTTPException(status_code=404, detail="Dewar not found")
|
|
|
|
# Process refill
|
|
dewar.last_refill = datetime.now()
|
|
|
|
# Calculate and update time until next refill
|
|
time_until_refill_seconds = calculate_time_until_refill(dewar.last_refill)
|
|
db.query(SlotModel).filter(SlotModel.dewar_unique_id == dewar.unique_id).update(
|
|
{'time_until_refill': time_until_refill_seconds})
|
|
|
|
new_event = LogisticsEventModel(
|
|
dewar_id=dewar.id, slot_id=None, # No specific slot, as it's a refill event
|
|
event_type="refill",
|
|
action_details=f"{dewar.unique_id} refilled"
|
|
)
|
|
db.add(new_event)
|
|
db.commit()
|
|
return {"message": "Dewar refilled successfully"} |