Merge pull request 'added feeding data objects and workflow' (#10) from support-add-feeding-entry into main

Reviewed-on: #10

src/baby_monitor/main.py

@@ -13,6 +13,7 @@ from baby_monitor.routers.auth import router as auth_router
 from baby_monitor.routers.auth import verify_token
 from baby_monitor.routers.admin import router as admin_router
 from baby_monitor.routers.child import router as child_router
+from baby_monitor.routers.feeding import router as feeding_router
 from baby_monitor.routers.health import router as health_router
 from baby_monitor.repositories.dependencies.get_database import init_db
 
@@ -49,6 +50,7 @@ app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
 app.include_router(auth_router)
 app.include_router(admin_router)
 app.include_router(child_router)
+app.include_router(feeding_router)
 app.include_router(health_router)
 
 
@@ -83,6 +85,12 @@ def serve_add_child() -> FileResponse:
     return FileResponse(static_path / "add-child.html")
 
 
+@app.get("/log-feeding.html", include_in_schema=False)
+def serve_log_feeding() -> FileResponse:
+    """Serve the log feeding page."""
+    return FileResponse(static_path / "log-feeding.html")
+
+
 @app.get("/api/")
 def read_root(token: Annotated[str, Depends(verify_token)]) -> dict:
     """API root endpoint (requires authentication)."""

src/baby_monitor/models/db/feeding.py

@@ -0,0 +1,28 @@
+"""Feeding database model."""
+
+from typing import TYPE_CHECKING
+from sqlalchemy import Column, Integer, DateTime, ForeignKey, String
+from datetime import datetime, UTC
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import DeclarativeBase
+
+    Base = DeclarativeBase
+else:
+    from baby_monitor.repositories.dependencies.get_database import Base
+
+
+class Feeding(Base):
+    """Feeding log database model."""
+
+    __tablename__ = "feedings"
+
+    id = Column(Integer, primary_key=True, index=True)
+    child_id = Column(Integer, ForeignKey("children.id"), nullable=False)
+    start_time = Column(DateTime, nullable=False)
+    end_time = Column(DateTime, nullable=True)
+    feeding_type = Column(String, nullable=False)  # stores FeedingType enum
+    created_at = Column(DateTime, default=datetime.now(UTC), nullable=False)
+
+    def __repr__(self) -> str:
+        return f"<Feeding(id={self.id}, child_id={self.child_id})>"

src/baby_monitor/models/enums.py

@@ -0,0 +1,11 @@
+"""Feeding type enumeration."""
+
+from enum import StrEnum
+
+
+class FeedingType(StrEnum):
+    """Enumeration of feeding types."""
+
+    LEFT_BREAST = "left_breast"
+    RIGHT_BREAST = "right_breast"
+    BOTTLE = "bottle"

src/baby_monitor/models/feeding.py

@@ -0,0 +1,35 @@
+"""Feeding-related request and response models."""
+
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+from baby_monitor.models.enums import FeedingType
+
+
+class CreateFeedingRequest(BaseModel):
+    """Request model for creating a feeding log."""
+
+    child_id: int = Field(..., gt=0)
+    start_time: datetime
+    end_time: datetime | None = None
+    feeding_type: FeedingType
+
+
+class UpdateFeedingRequest(BaseModel):
+    """Request model for updating a feeding log."""
+
+    start_time: datetime | None = None
+    end_time: datetime | None = None
+    feeding_type: FeedingType | None = None
+
+
+class FeedingResponse(BaseModel):
+    """Response model for feeding log data."""
+
+    id: int
+    child_id: int
+    start_time: datetime
+    end_time: datetime | None
+    feeding_type: str
+    created_at: datetime
+    child_name: str | None = None  # Optional, populated when needed

src/baby_monitor/repositories/dependencies/get_database.py

@@ -78,6 +78,7 @@ def init_db() -> None:
     # This must be done before create_all() is called
     from baby_monitor.models.db.user import User  # noqa: F401
     from baby_monitor.models.db.child import Child  # noqa: F401
+    from baby_monitor.models.db.feeding import Feeding  # noqa: F401
     from baby_monitor.models.invitation import Invitation  # noqa: F401
 
     # Ensure data directory exists

src/baby_monitor/repositories/dependencies/get_feeding_repository.py

@@ -0,0 +1,17 @@
+"""Dependency for getting feeding repository instance."""
+
+from typing import Annotated
+from fastapi import Depends
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.dependencies.get_database import get_database
+from baby_monitor.repositories.feeding.sqlite_feeding import (
+    SQLiteFeedingRepository,
+)
+
+
+def get_feeding_repository(
+    db: Annotated[Session, Depends(get_database)],
+) -> SQLiteFeedingRepository:
+    """Get feeding repository instance."""
+    return SQLiteFeedingRepository(db)

src/baby_monitor/repositories/feeding/sqlite_feeding.py

@@ -0,0 +1,109 @@
+"""SQLite implementation of feeding repository."""
+
+from datetime import datetime
+from sqlalchemy.orm import Session
+
+from baby_monitor.repositories.interfaces.feeding_repository_interface import (
+    FeedingRepositoryInterface,
+)
+from baby_monitor.models.db.feeding import Feeding
+from baby_monitor.models.db.child import Child
+
+
+class SQLiteFeedingRepository(FeedingRepositoryInterface):
+    """SQLite implementation for feeding log data access."""
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create(
+        self,
+        child_id: int,
+        start_time: datetime,
+        feeding_type: str,
+        end_time: datetime | None = None,
+    ) -> dict:
+        """Create a new feeding log entry."""
+        feeding = Feeding(
+            child_id=child_id,
+            start_time=start_time,
+            end_time=end_time,
+            feeding_type=feeding_type,
+        )
+        self.db.add(feeding)
+        self.db.commit()
+        self.db.refresh(feeding)
+
+        return self._to_dict(feeding)
+
+    def get_by_id(self, feeding_id: int) -> dict | None:
+        """Get a feeding log by ID."""
+        feeding = self.db.query(Feeding).filter(Feeding.id == feeding_id).first()
+        if not feeding:
+            return None
+        return self._to_dict(feeding)
+
+    def get_by_child_id(self, child_id: int) -> list[dict]:
+        """Get all feeding logs for a specific child."""
+        feedings = (
+            self.db.query(Feeding)
+            .filter(Feeding.child_id == child_id)
+            .order_by(Feeding.start_time.desc())
+            .all()
+        )
+        return [self._to_dict(feeding) for feeding in feedings]
+
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all feeding logs for a specific user's children."""
+        feedings = (
+            self.db.query(Feeding)
+            .join(Child)
+            .filter(Child.user_id == user_id)
+            .order_by(Feeding.start_time.desc())
+            .all()
+        )
+        return [self._to_dict(feeding) for feeding in feedings]
+
+    def update(
+        self,
+        feeding_id: int,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        feeding_type: str | None = None,
+    ) -> dict | None:
+        """Update a feeding log entry."""
+        feeding = self.db.query(Feeding).filter(Feeding.id == feeding_id).first()
+        if not feeding:
+            return None
+
+        if start_time is not None:
+            feeding.start_time = start_time  # type: ignore[assignment]
+        if end_time is not None:
+            feeding.end_time = end_time  # type: ignore[assignment]
+        if feeding_type is not None:
+            feeding.feeding_type = feeding_type  # type: ignore[assignment]
+
+        self.db.commit()
+        self.db.refresh(feeding)
+        return self._to_dict(feeding)
+
+    def delete(self, feeding_id: int) -> bool:
+        """Delete a feeding log entry."""
+        feeding = self.db.query(Feeding).filter(Feeding.id == feeding_id).first()
+        if not feeding:
+            return False
+
+        self.db.delete(feeding)
+        self.db.commit()
+        return True
+
+    def _to_dict(self, feeding: Feeding) -> dict:
+        """Convert Feeding model to dictionary."""
+        return {
+            "id": feeding.id,
+            "child_id": feeding.child_id,
+            "start_time": feeding.start_time,
+            "end_time": feeding.end_time,
+            "feeding_type": feeding.feeding_type,
+            "created_at": feeding.created_at,
+        }

src/baby_monitor/repositories/interfaces/feeding_repository_interface.py

@@ -0,0 +1,44 @@
+"""Interface for feeding repository operations."""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+
+class FeedingRepositoryInterface(ABC):
+    """Interface for feeding log data access operations."""
+
+    @abstractmethod
+    def create(
+        self,
+        child_id: int,
+        start_time: datetime,
+        feeding_type: str,
+        end_time: datetime | None = None,
+    ) -> dict:
+        """Create a new feeding log entry."""
+
+    @abstractmethod
+    def get_by_id(self, feeding_id: int) -> dict | None:
+        """Get a feeding log by ID."""
+
+    @abstractmethod
+    def get_by_child_id(self, child_id: int) -> list[dict]:
+        """Get all feeding logs for a specific child."""
+
+    @abstractmethod
+    def get_by_user_id(self, user_id: int) -> list[dict]:
+        """Get all feeding logs for a specific user's children."""
+
+    @abstractmethod
+    def update(
+        self,
+        feeding_id: int,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        feeding_type: str | None = None,
+    ) -> dict | None:
+        """Update a feeding log entry."""
+
+    @abstractmethod
+    def delete(self, feeding_id: int) -> bool:
+        """Delete a feeding log entry."""

src/baby_monitor/routers/feeding.py

@@ -0,0 +1,158 @@
+"""Feeding log management router."""
+
+from typing import Annotated
+from fastapi import APIRouter, HTTPException, Depends
+
+from baby_monitor.models.feeding import (
+    CreateFeedingRequest,
+    UpdateFeedingRequest,
+    FeedingResponse,
+)
+from baby_monitor.routers.auth import verify_token
+from baby_monitor.repositories.feeding.sqlite_feeding import (
+    SQLiteFeedingRepository,
+)
+from baby_monitor.repositories.dependencies.get_feeding_repository import (
+    get_feeding_repository,
+)
+from baby_monitor.repositories.child.sqlite_child import SQLiteChildRepository
+from baby_monitor.repositories.dependencies.get_child_repository import (
+    get_child_repository,
+)
+
+router = APIRouter(prefix="/api/feedings", tags=["feedings"])
+
+
+@router.post("", response_model=FeedingResponse, status_code=201)
+def create_feeding(
+    request: CreateFeedingRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> FeedingResponse:
+    """Create a new feeding log entry."""
+    # Verify the child belongs to the authenticated user
+    child = child_repo.get_by_id(request.child_id)
+    if not child:
+        raise HTTPException(status_code=404, detail="Child not found")
+
+    if child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied to this child")
+
+    feeding = feeding_repo.create(
+        child_id=request.child_id,
+        start_time=request.start_time,
+        end_time=request.end_time,
+        feeding_type=request.feeding_type.value,
+    )
+
+    return FeedingResponse(**feeding)
+
+
+@router.get("/active", response_model=FeedingResponse | None)
+def get_active_feeding(
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> FeedingResponse | None:
+    """Get the current active feeding (where end_time is null) for the user."""
+    feedings = feeding_repo.get_by_user_id(user_id)
+
+    # Find the first feeding with no end_time
+    for feeding in feedings:
+        if feeding["end_time"] is None:
+            # Get child info to include in response
+            child = child_repo.get_by_id(feeding["child_id"])
+            response_data = feeding.copy()
+            if child:
+                response_data["child_name"] = child["name"]
+            return FeedingResponse(**response_data)
+
+    return None
+
+
+@router.get("", response_model=list[FeedingResponse])
+def get_user_feedings(
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+) -> list[FeedingResponse]:
+    """Get all feeding logs for the authenticated user's children."""
+    feedings = feeding_repo.get_by_user_id(user_id)
+    return [FeedingResponse(**feeding) for feeding in feedings]
+
+
+@router.get("/{feeding_id}", response_model=FeedingResponse)
+def get_feeding(
+    feeding_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> FeedingResponse:
+    """Get a specific feeding log by ID."""
+    feeding = feeding_repo.get_by_id(feeding_id)
+
+    if not feeding:
+        raise HTTPException(status_code=404, detail="Feeding log not found")
+
+    # Verify the feeding belongs to user's child
+    child = child_repo.get_by_id(feeding["child_id"])
+    if not child or child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    return FeedingResponse(**feeding)
+
+
+@router.put("/{feeding_id}", response_model=FeedingResponse)
+def update_feeding(
+    feeding_id: int,
+    request: UpdateFeedingRequest,
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> FeedingResponse:
+    """Update a feeding log entry."""
+    feeding = feeding_repo.get_by_id(feeding_id)
+
+    if not feeding:
+        raise HTTPException(status_code=404, detail="Feeding log not found")
+
+    # Verify ownership
+    child = child_repo.get_by_id(feeding["child_id"])
+    if not child or child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    # Update the feeding
+    updated_feeding = feeding_repo.update(
+        feeding_id=feeding_id,
+        start_time=request.start_time,
+        end_time=request.end_time,
+        feeding_type=request.feeding_type.value if request.feeding_type else None,
+    )
+
+    if not updated_feeding:
+        raise HTTPException(status_code=500, detail="Update failed")
+
+    return FeedingResponse(**updated_feeding)
+
+
+@router.delete("/{feeding_id}", status_code=204)
+def delete_feeding(
+    feeding_id: int,
+    user_id: Annotated[int, Depends(verify_token)],
+    feeding_repo: Annotated[SQLiteFeedingRepository, Depends(get_feeding_repository)],
+    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
+) -> None:
+    """Delete a feeding log entry."""
+    feeding = feeding_repo.get_by_id(feeding_id)
+
+    if not feeding:
+        raise HTTPException(status_code=404, detail="Feeding log not found")
+
+    # Verify ownership
+    child = child_repo.get_by_id(feeding["child_id"])
+    if not child or child["user_id"] != user_id:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    success = feeding_repo.delete(feeding_id)
+    if not success:
+        raise HTTPException(status_code=500, detail="Delete failed")

src/baby_monitor/static/index.html

@@ -117,6 +117,92 @@
         text-align: center;
         padding: 2rem;
       }
+      .feeding-button {
+        width: 100%;
+        padding: 2rem;
+        font-size: 1.5rem;
+        margin-bottom: 1.5rem;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 8px;
+        transition:
+          transform 0.2s,
+          box-shadow 0.2s;
+      }
+      .feeding-button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 6px 20px rgba(102, 126, 234, 0.4);
+        background: linear-gradient(135deg, #764ba2 0%, #667eea 100%);
+      }
+      .feeding-button.active {
+        background: linear-gradient(135deg, #f44336 0%, #e91e63 100%);
+      }
+      .feeding-button.active:hover {
+        background: linear-gradient(135deg, #e91e63 0%, #f44336 100%);
+      }
+      .feeding-info {
+        font-size: 0.9rem;
+        margin-top: 0.5rem;
+        opacity: 0.9;
+      }
+      .modal {
+        display: none;
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        z-index: 1001;
+        justify-content: center;
+        align-items: center;
+      }
+      .modal.show {
+        display: flex;
+      }
+      .modal-content {
+        background: white;
+        padding: 2rem;
+        border-radius: 8px;
+        max-width: 400px;
+        width: 90%;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.3);
+      }
+      .modal h2 {
+        margin-top: 0;
+        margin-bottom: 1.5rem;
+        color: #333;
+      }
+      .form-group {
+        margin-bottom: 1rem;
+      }
+      .form-group label {
+        display: block;
+        margin-bottom: 0.5rem;
+        color: #333;
+        font-weight: 600;
+      }
+      .form-group select {
+        width: 100%;
+        padding: 0.75rem;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+        font-size: 1rem;
+      }
+      .modal-buttons {
+        display: flex;
+        gap: 0.5rem;
+        margin-top: 1.5rem;
+      }
+      .modal-buttons button {
+        flex: 1;
+        margin: 0;
+      }
+      .cancel-button {
+        background-color: #6c757d;
+      }
+      .cancel-button:hover {
+        background-color: #5a6268;
+      }
     </style>
   </head>
   <body>
@@ -139,6 +225,40 @@
       </div>
     </div>
 
+    <!-- Start Feeding Modal -->
+    <div class="modal" id="startFeedingModal">
+      <div class="modal-content">
+        <h2>🍼 Start Feeding</h2>
+        <form id="startFeedingForm">
+          <div class="form-group">
+            <label for="modalChildId">Child</label>
+            <select id="modalChildId" required>
+              <option value="">Select a child</option>
+            </select>
+          </div>
+          <div class="form-group">
+            <label for="modalFeedingType">Feeding Type</label>
+            <select id="modalFeedingType" required>
+              <option value="">Select type</option>
+              <option value="left_breast">Left Breast</option>
+              <option value="right_breast">Right Breast</option>
+              <option value="bottle">Bottle</option>
+            </select>
+          </div>
+          <div class="modal-buttons">
+            <button
+              type="button"
+              class="cancel-button"
+              onclick="closeStartFeedingModal()"
+            >
+              Cancel
+            </button>
+            <button type="submit">Start</button>
+          </div>
+        </form>
+      </div>
+    </div>
+
     <script>
       const token = localStorage.getItem("access_token");
       const username = localStorage.getItem("username");
@@ -206,14 +326,8 @@
                   return;
                 }
 
-                // Show authenticated content
-                document.getElementById("content").innerHTML = `
-                    <h1>Welcome to Baby Monitor!</h1>
-                    <div class="user-info">
-                        <p><strong>Logged in as:</strong> ${username}</p>
-                    </div>
-                    <p>Your session is active.</p>
-                `;
+                // Load feeding status and show content
+                loadFeedingStatus(children);
               });
           })
           .catch((error) => {
@@ -221,6 +335,249 @@
           });
       }
 
+      let activeFeeding = null;
+      let userChildren = [];
+      let lastFeeding = null;
+      let updateTimerInterval = null;
+
+      async function loadFeedingStatus(children) {
+        userChildren = children;
+
+        try {
+          // Fetch active feeding
+          const activeResponse = await fetch("/api/feedings/active", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (activeResponse.ok) {
+            activeFeeding = await activeResponse.json();
+          }
+
+          // Fetch all feedings to get the last one
+          const feedingsResponse = await fetch("/api/feedings", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (feedingsResponse.ok) {
+            const feedings = await feedingsResponse.json();
+            if (feedings.length > 0) {
+              // Feedings are ordered by start_time desc, so first is most recent
+              lastFeeding = feedings[0];
+            }
+          }
+        } catch (error) {
+          console.error("Error loading feeding status:", error);
+        }
+
+        renderContent();
+        startUpdateTimer();
+      }
+
+      function startUpdateTimer() {
+        // Clear any existing timer
+        if (updateTimerInterval) {
+          clearInterval(updateTimerInterval);
+        }
+
+        // Update every 30 seconds if there's an active feeding
+        if (activeFeeding) {
+          updateTimerInterval = setInterval(() => {
+            if (activeFeeding) {
+              updateFeedingTimeDisplay();
+            } else {
+              clearInterval(updateTimerInterval);
+              updateTimerInterval = null;
+            }
+          }, 30000); // Update every 30 seconds
+        }
+      }
+
+      function updateFeedingTimeDisplay() {
+        const timeElement = document.getElementById("feedingTimeInfo");
+        if (timeElement && activeFeeding) {
+          timeElement.textContent = formatTime(activeFeeding.start_time);
+        }
+      }
+
+      function renderContent() {
+        const feedingButtonHtml = activeFeeding
+          ? `
+            <button class="feeding-button active" onclick="stopFeeding()">
+              🛑 Stop Feeding
+              <div class="feeding-info">
+                ${activeFeeding.child_name || "Child"} - ${formatFeedingType(activeFeeding.feeding_type)}<br>
+                Started <span id="feedingTimeInfo">${formatTime(activeFeeding.start_time)}</span>
+              </div>
+            </button>
+          `
+          : `
+            <button class="feeding-button" onclick="showStartFeedingModal()">
+              ▶️ Start Feeding
+            </button>
+          `;
+
+        document.getElementById("content").innerHTML = `
+          <h1>Welcome to Baby Monitor!</h1>
+          <div class="user-info">
+            <p><strong>Logged in as:</strong> ${username}</p>
+          </div>
+          ${feedingButtonHtml}
+          <p>Your session is active.</p>
+        `;
+      }
+
+      function formatFeedingType(type) {
+        const types = {
+          left_breast: "Left Breast",
+          right_breast: "Right Breast",
+          bottle: "Bottle",
+        };
+        return types[type] || type;
+      }
+
+      function formatTime(dateString) {
+        const date = new Date(dateString);
+        const now = new Date();
+        const diffMs = now - date;
+        const diffMins = Math.floor(diffMs / 60000);
+
+        if (diffMins < 1) return "just now";
+        if (diffMins < 60) return `${diffMins} min ago`;
+
+        const diffHours = Math.floor(diffMins / 60);
+        if (diffHours < 24) return `${diffHours}h ${diffMins % 60}m ago`;
+
+        return date.toLocaleString();
+      }
+
+      function showStartFeedingModal() {
+        const modal = document.getElementById("startFeedingModal");
+        const childSelect = document.getElementById("modalChildId");
+        const typeSelect = document.getElementById("modalFeedingType");
+
+        // Clear and populate child select
+        childSelect.innerHTML = '<option value="">Select a child</option>';
+        userChildren.forEach((child) => {
+          const option = document.createElement("option");
+          option.value = child.id;
+          option.textContent = child.name;
+          childSelect.appendChild(option);
+        });
+
+        // Set defaults based on last feeding
+        if (lastFeeding) {
+          childSelect.value = lastFeeding.child_id;
+          typeSelect.value = lastFeeding.feeding_type;
+        }
+
+        modal.classList.add("show");
+      }
+
+      function closeStartFeedingModal() {
+        const modal = document.getElementById("startFeedingModal");
+        modal.classList.remove("show");
+        document.getElementById("startFeedingForm").reset();
+      }
+
+      document
+        .getElementById("startFeedingForm")
+        .addEventListener("submit", async (e) => {
+          e.preventDefault();
+
+          const childId = parseInt(
+            document.getElementById("modalChildId").value,
+          );
+          const feedingType = document.getElementById("modalFeedingType").value;
+
+          try {
+            const now = new Date();
+            const localDateTime = new Date(
+              now.getTime() - now.getTimezoneOffset() * 60000,
+            )
+              .toISOString()
+              .slice(0, 19);
+
+            const response = await fetch("/api/feedings", {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+              },
+              body: JSON.stringify({
+                child_id: childId,
+                start_time: localDateTime,
+                end_time: null,
+                feeding_type: feedingType,
+              }),
+            });
+
+            if (response.ok) {
+              const feeding = await response.json();
+              activeFeeding = feeding;
+              lastFeeding = feeding; // Update last feeding
+
+              // Add child name to active feeding
+              const child = userChildren.find((c) => c.id === childId);
+              if (child) {
+                activeFeeding.child_name = child.name;
+              }
+
+              closeStartFeedingModal();
+              renderContent();
+              startUpdateTimer(); // Start the timer for live updates
+            } else {
+              const data = await response.json();
+              alert(data.detail || "Failed to start feeding");
+            }
+          } catch (error) {
+            console.error("Error starting feeding:", error);
+            alert("Network error. Please try again.");
+          }
+        });
+
+      async function stopFeeding() {
+        if (!activeFeeding) return;
+
+        try {
+          const now = new Date();
+          const localDateTime = new Date(
+            now.getTime() - now.getTimezoneOffset() * 60000,
+          )
+            .toISOString()
+            .slice(0, 19);
+
+          const response = await fetch(`/api/feedings/${activeFeeding.id}`, {
+            method: "PUT",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              end_time: localDateTime,
+            }),
+          });
+
+          if (response.ok) {
+            activeFeeding = null;
+            if (updateTimerInterval) {
+              clearInterval(updateTimerInterval);
+              updateTimerInterval = null;
+            }
+            renderContent();
+          } else {
+            const data = await response.json();
+            alert(data.detail || "Failed to stop feeding");
+          }
+        } catch (error) {
+          console.error("Error stopping feeding:", error);
+          alert("Network error. Please try again.");
+        }
+      }
+
       async function logout() {
         const token = localStorage.getItem("access_token");
 

src/baby_monitor/static/log-feeding.html

@@ -0,0 +1,328 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Log Feeding - Baby Monitor</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+
+      body {
+        font-family:
+          -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu,
+          Cantarell, sans-serif;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        min-height: 100vh;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        padding: 20px;
+      }
+
+      .container {
+        background: white;
+        border-radius: 12px;
+        box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+        padding: 40px;
+        max-width: 500px;
+        width: 100%;
+      }
+
+      h1 {
+        color: #333;
+        margin-bottom: 10px;
+        font-size: 28px;
+      }
+
+      .subtitle {
+        color: #666;
+        margin-bottom: 30px;
+        font-size: 14px;
+      }
+
+      .form-group {
+        margin-bottom: 20px;
+      }
+
+      label {
+        display: block;
+        margin-bottom: 8px;
+        color: #333;
+        font-weight: 600;
+        font-size: 14px;
+      }
+
+      input,
+      select {
+        width: 100%;
+        padding: 12px;
+        border: 1px solid #ddd;
+        border-radius: 6px;
+        font-size: 14px;
+        transition: border-color 0.2s;
+      }
+
+      input:focus,
+      select:focus {
+        outline: none;
+        border-color: #667eea;
+      }
+
+      .button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border: none;
+        padding: 12px 24px;
+        border-radius: 6px;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition:
+          transform 0.2s,
+          box-shadow 0.2s;
+        width: 100%;
+        margin-top: 10px;
+      }
+
+      .button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+      }
+
+      .button:active {
+        transform: translateY(0);
+      }
+
+      .button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+        transform: none;
+      }
+
+      .button.secondary {
+        background: #6c757d;
+        margin-top: 10px;
+      }
+
+      .button.secondary:hover {
+        box-shadow: 0 4px 12px rgba(108, 117, 125, 0.4);
+      }
+
+      .message {
+        padding: 12px;
+        border-radius: 6px;
+        margin-bottom: 20px;
+        display: none;
+      }
+
+      .message.show {
+        display: block;
+      }
+
+      .message.error {
+        background: #ffebee;
+        border-left: 4px solid #f44336;
+        color: #c62828;
+      }
+
+      .message.success {
+        background: #e8f5e9;
+        border-left: 4px solid #4caf50;
+        color: #2e7d32;
+      }
+
+      .help-text {
+        font-size: 12px;
+        color: #666;
+        margin-top: 4px;
+      }
+
+      .loading {
+        text-align: center;
+        padding: 20px;
+        color: #666;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>🍼 Log Feeding</h1>
+      <p class="subtitle">Record a feeding session</p>
+
+      <div id="message" class="message"></div>
+
+      <div id="loadingChildren" class="loading">Loading children...</div>
+
+      <form id="logFeedingForm" style="display: none">
+        <div class="form-group">
+          <label for="childId">Child *</label>
+          <select id="childId" name="childId" required>
+            <option value="">Select a child</option>
+          </select>
+        </div>
+
+        <div class="form-group">
+          <label for="startTime">Start Time *</label>
+          <input
+            type="datetime-local"
+            id="startTime"
+            name="startTime"
+            required
+          />
+          <p class="help-text">Defaults to current time</p>
+        </div>
+
+        <div class="form-group">
+          <label for="endTime">End Time</label>
+          <input type="datetime-local" id="endTime" name="endTime" />
+          <p class="help-text">Leave empty if feeding is ongoing</p>
+        </div>
+
+        <div class="form-group">
+          <label for="feedingType">Feeding Type *</label>
+          <select id="feedingType" name="feedingType" required>
+            <option value="">Select type</option>
+            <option value="left_breast">Left Breast</option>
+            <option value="right_breast">Right Breast</option>
+            <option value="bottle">Bottle</option>
+          </select>
+        </div>
+
+        <button type="submit" class="button" id="submitBtn">Log Feeding</button>
+        <button type="button" class="button secondary" onclick="goBack()">
+          Cancel
+        </button>
+      </form>
+    </div>
+
+    <script>
+      // Check if user is authenticated
+      const token = localStorage.getItem("access_token");
+      if (!token) {
+        window.location.href = "/login.html";
+      }
+
+      const form = document.getElementById("logFeedingForm");
+      const messageDiv = document.getElementById("message");
+      const submitBtn = document.getElementById("submitBtn");
+      const loadingDiv = document.getElementById("loadingChildren");
+      const childSelect = document.getElementById("childId");
+
+      // Set default start time to now
+      const now = new Date();
+      const localDateTime = new Date(
+        now.getTime() - now.getTimezoneOffset() * 60000,
+      )
+        .toISOString()
+        .slice(0, 16);
+      document.getElementById("startTime").value = localDateTime;
+
+      // Load user's children
+      async function loadChildren() {
+        try {
+          const response = await fetch("/api/children", {
+            headers: {
+              Authorization: `Bearer ${token}`,
+            },
+          });
+
+          if (response.ok) {
+            const children = await response.json();
+
+            if (children.length === 0) {
+              showMessage(
+                "No children found. Please add a child first.",
+                "error",
+              );
+              setTimeout(() => {
+                window.location.href = "/add-child.html";
+              }, 2000);
+              return;
+            }
+
+            // Populate select dropdown
+            children.forEach((child) => {
+              const option = document.createElement("option");
+              option.value = child.id;
+              option.textContent = child.name;
+              childSelect.appendChild(option);
+            });
+
+            // Show form, hide loading
+            loadingDiv.style.display = "none";
+            form.style.display = "block";
+          } else {
+            showMessage("Failed to load children", "error");
+          }
+        } catch (error) {
+          showMessage("Network error loading children", "error");
+        }
+      }
+
+      loadChildren();
+
+      form.addEventListener("submit", async (e) => {
+        e.preventDefault();
+
+        const childId = parseInt(document.getElementById("childId").value);
+        const startTime = document.getElementById("startTime").value;
+        const endTimeValue = document.getElementById("endTime").value;
+        const feedingType = document.getElementById("feedingType").value;
+
+        // Disable button during request
+        submitBtn.disabled = true;
+        submitBtn.textContent = "Logging...";
+        messageDiv.classList.remove("show");
+
+        try {
+          const response = await fetch("/api/feedings", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              child_id: childId,
+              start_time: startTime,
+              end_time: endTimeValue || null,
+              feeding_type: feedingType,
+            }),
+          });
+
+          const data = await response.json();
+
+          if (response.ok) {
+            showMessage("Feeding logged successfully!", "success");
+            // Redirect to home page after 1 second
+            setTimeout(() => {
+              window.location.href = "/";
+            }, 1000);
+          } else {
+            showMessage(
+              data.detail || "Failed to log feeding. Please try again.",
+              "error",
+            );
+          }
+        } catch (error) {
+          showMessage("Network error. Please try again.", "error");
+        } finally {
+          submitBtn.disabled = false;
+          submitBtn.textContent = "Log Feeding";
+        }
+      });
+
+      function showMessage(text, type) {
+        messageDiv.textContent = text;
+        messageDiv.className = `message ${type} show`;
+      }
+
+      function goBack() {
+        window.location.href = "/";
+      }
+    </script>
+  </body>
+</html>