Merge pull request 'added diaper overview page' (#16 ) from add-diaper-change-overview into main

Reviewed-on: #16
added diaper overview page
2025-11-10 16:26:43 +01:00 · 2025-11-10 16:24:07 +01:00 · 2025-11-10 15:59:45 +01:00 · 2025-11-10 15:56:57 +01:00 · 2025-11-10 15:56:08 +01:00 · 2025-11-10 15:55:26 +01:00
73 changed files with 8506 additions and 120 deletions
@@ -0,0 +1,79 @@
 name: Build and Push Docker Image
 on:
  push:
    branches:
      - main
    tags:
      - "v*"
  pull_request:
    branches:
      - main
 jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
        with:
          config-inline: |
            [registry."${{ secrets.DOCKER_REGISTRY }}"]
              http = true
              insecure = true
      - name: Log in to Gitea Container Registry
        run: |
          # Configure Docker to allow insecure registry for this session
          mkdir -p ~/.docker
          echo '{
            "auths": {},
            "insecure-registries": ["${{ secrets.DOCKER_REGISTRY }}"]
          }' > ~/.docker/config.json
          # Login using direct docker command
          echo "${{ secrets.CI_RUNNER_TOKEN }}" | docker login ${{ secrets.DOCKER_REGISTRY }} --username "${{ gitea.actor }}" --password-stdin
      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: |
            ${{ secrets.DOCKER_REGISTRY }}/${{ gitea.repository_owner }}/${{ gitea.event.repository.name }}
          tags: |
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=semver,pattern={{major}}
            type=sha
            type=raw,value=latest,enable={{is_default_branch}}
          labels: |
            org.opencontainers.image.title=baby-monitor
            org.opencontainers.image.description=Baby Monitor App with all optional dependencies included
            org.opencontainers.image.authors=Brian Bjarke Jensen
            org.opencontainers.image.vendor=Brian Bjarke Jensen
            org.opencontainers.image.licenses=MIT
      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          file: ./Dockerfile
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max
          platforms: linux/amd64,linux/arm64
      - name: Update deployment info
        run: |
          echo "Docker image built and pushed successfully at $(date)"
          echo "Image tags:"
          echo "${{ steps.meta.outputs.tags }}"
          echo "Image labels:"
          echo "${{ steps.meta.outputs.labels }}"
@@ -62,6 +62,9 @@ local_settings.py
 db.sqlite3
 db.sqlite3-journal
 # SQLite database files
 *.db
 # Flask stuff:
 instance/
 .webassets-cache
@@ -7,7 +7,8 @@ ENV PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1 \
    UV_PROJECT_ENVIRONMENT=/app/.venv \
-    ENVIRONMENT=production
+    ENVIRONMENT=production \
    DATA_DIR=/data
 # Set working directory
 WORKDIR /app
@@ -18,14 +19,18 @@ COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 # Copy dependency files
 COPY pyproject.toml README.md ./
-# Install Python dependencies
+# Copy application code
-RUN uv sync --no-dev
+COPY src/ ./src/
 # Install Python dependencies including all optional dependencies
 # This makes the image self-contained and ready for any configuration
 RUN uv sync --no-dev --all-extras
 # Add virtual environment to PATH
 ENV PATH="/app/.venv/bin:$PATH"
-# Copy application code
+# Create data directory for SQLite database
-COPY src/ ./src/
+RUN mkdir -p /data && chmod 777 /data
 # Add healthcheck
 HEALTHCHECK \
@@ -39,6 +44,9 @@ HEALTHCHECK \
 # Expose port
 EXPOSE 8000
 # Declare volume for persistent data
 VOLUME /data
 # Set entrypoint to restrict usage to uvicorn with this specific app
 ENTRYPOINT ["uvicorn", "src.baby_monitor.main:app"]
@@ -1,3 +1,264 @@
-# baby-monitor
+# 👶 Baby Monitor
-Baby monitor app that helps track feeding, sleeping and diaper changes for a child.
+A self-hosted FastAPI web application for tracking baby activities including feeding, sleeping, and diaper changes. Built with modern Python tools and designed for easy deployment with Docker.
 [![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=flat&logo=docker&logoColor=white)](https://www.docker.com/)
 [![FastAPI](https://img.shields.io/badge/FastAPI-005571?style=flat&logo=fastapi)](https://fastapi.tiangolo.com)
 [![Python](https://img.shields.io/badge/python-3.12+-blue.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
 ## ✨ Features
 - 🔐 **Secure Authentication** - Token-based authentication with environment-configured credentials
 - 💾 **Flexible Storage** - SQLite by default with PostgreSQL support
 - 🚀 **Scalable Sessions** - In-memory tokens with optional Redis for distributed deployments
 - 📦 **Self-Contained** - Docker image includes all optional dependencies
 - 🔌 **Repository Pattern** - Clean architecture with swappable backends
 - 🏥 **Health Checks** - Built-in health and readiness endpoints
 - 🌐 **SPA Frontend** - Modern single-page application interface
 - 🐳 **Docker Ready** - Production-ready Dockerfile with multi-architecture support
 ## 🚀 Quick Start
 ### Using Docker (Recommended)
 ```bash
 # Pull and run the latest image
 docker run -d \
  --name baby-monitor \
  -p 8000:8000 \
  -e ADMIN_PASSWORD=your-secure-password \
  -v baby_monitor_data:/data \
  gitea.gt-proj.com/brian/baby-monitor:latest
 # Access the application
 open http://localhost:8000
 ```
 ### Using Docker Compose
 ```yaml
 services:
  baby-monitor:
    image: gitea.gt-proj.com/brian/baby-monitor:latest
    container_name: baby-monitor
    ports:
      - "8000:8000"
    environment:
      - ENVIRONMENT=production
      - ADMIN_PASSWORD=${ADMIN_PASSWORD}
      # Optional: Use Redis for distributed token storage
      # - REDIS_URI=redis://redis:6379
    volumes:
      - ./data:/data
    restart: unless-stopped
  # Optional: Redis for token storage
  # redis:
  #   image: redis:7-alpine
  #   restart: unless-stopped
 ```
 ### Local Development
 ```bash
 # Clone the repository
 git clone https://gitea.gt-proj.com/brian/baby-monitor.git
 cd baby-monitor
 # Install dependencies with uv
 uv sync --all-extras
 # Set environment variables
 export ENVIRONMENT=development
 export ADMIN_PASSWORD=password
 export DATA_DIR=./data
 # Run the application
 uv run uvicorn src.baby_monitor.main:app --reload --host 0.0.0.0 --port 8000
 ```
 ## 🔧 Configuration
 ### Environment Variables
 | Variable         | Default      | Description                                 |
 | ---------------- | ------------ | ------------------------------------------- |
 | `ENVIRONMENT`    | `production` | Set to `development` to enable API docs     |
 | `ADMIN_PASSWORD` | _(required)_ | Admin user password                         |
 | `ADMIN_USERNAME` | `admin`      | Admin username                              |
 | `DATA_DIR`       | `/data`      | Directory for SQLite database               |
 | `REDIS_URI`      | _(optional)_ | Redis connection URI for distributed tokens |
 ### Storage Options
 **SQLite (Default)**
 - Automatic setup, no configuration needed
 - Data stored in `/data/baby_monitor.db`
 - Perfect for single-server deployments
 **Redis (Optional)**
 ```bash
 # Enable Redis token storage
 export REDIS_URI=redis://localhost:6379
 ```
 **PostgreSQL (Future)**
 - Repository interface ready
 - Swap implementation in `dependencies.py`
 ## 📁 Project Structure
 ```
 baby-monitor/
 ├── src/baby_monitor/
 │   ├── main.py                     # FastAPI application
 │   ├── models/                     # Pydantic models
 │   ├── routers/                    # API endpoints
 │   │   ├── auth.py                # Authentication routes
 │   │   └── health.py              # Health check routes
 │   ├── repositories/               # Data access layer
 │   │   ├── interfaces.py          # Abstract interfaces
 │   │   ├── user/                  # User repositories
 │   │   ├── token/                 # Token storage
 │   │   └── credentials/           # Credentials management
 │   └── static/                    # Frontend files
 ├── tests/                         # Test suite
 │   ├── integration/               # Integration tests
 │   └── unit/                      # Unit tests
 ├── Dockerfile                     # Production container
 ├── docker-compose.yml             # Local development
 └── pyproject.toml                 # Project dependencies
 ```
 ## 🏗️ Architecture
 ### Repository Pattern
 The application uses the **Repository Pattern** for data access, allowing easy swapping of backends:
 ```python
 # Switch from SQLite to PostgreSQL
 from baby_monitor.repositories.user.postgresql_user import PostgreSQLUserRepository
 return PostgreSQLUserRepository(db)
 # Switch from in-memory to Redis tokens
 # Just set REDIS_URI environment variable
 ```
 ### Technology Stack
 - **Backend**: FastAPI + SQLAlchemy 2.0
 - **Database**: SQLite (default) / PostgreSQL (ready)
 - **Cache**: In-memory (default) / Redis (optional)
 - **Package Manager**: uv
 - **Container**: Docker with multi-stage builds
 ## 🧪 Testing
 ```bash
 # Run all tests
 uv run pytest
 # Run with coverage
 uv run pytest --cov-report=term-missing --cov=src/baby_monitor
 # Run specific test types
 uv run pytest tests/unit/
 uv run pytest tests/integration/
 ```
 ## 🔒 Security
 - ✅ Token-based authentication
 - ✅ Environment-based secrets (no hardcoded credentials)
 - ✅ API docs disabled in production
 - ✅ CORS configuration ready
 - ⚠️ **TODO**: Add password hashing (currently plain text comparison)
 - ⚠️ **TODO**: Implement rate limiting
 ## 🚀 Deployment
 ### Unraid
 1. Add the repository to Community Applications
 2. Configure environment variables
 3. Map `/data` volume for persistence
 4. Set admin password
 ### Docker Swarm / Kubernetes
 The application is stateless when using Redis for tokens, making it suitable for:
 - Multi-replica deployments
 - Load balancing
 - Rolling updates
 ### CI/CD
 Gitea Actions workflow included:
 - Builds multi-architecture images (amd64, arm64)
 - Automatic semantic versioning
 - Pushes to container registry
 - Health checks and metadata
 ## 📊 API Documentation
 When running in development mode (`ENVIRONMENT=development`):
 - **OpenAPI Docs**: http://localhost:8000/docs
 - **ReDoc**: http://localhost:8000/redoc
 - **OpenAPI JSON**: http://localhost:8000/openapi.json
 ### Key Endpoints
 | Endpoint      | Method | Description            |
 | ------------- | ------ | ---------------------- |
 | `/`           | GET    | Serve home page        |
 | `/api/`       | GET    | Authenticated API root |
 | `/api/login`  | POST   | User authentication    |
 | `/api/logout` | POST   | Invalidate token       |
 | `/health`     | GET    | Health check           |
 | `/ready`      | GET    | Readiness probe        |
 | `/info`       | GET    | Feature detection      |
 ## 🤝 Contributing
 Contributions are welcome! Please:
 1. Fork the repository
 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
 3. Commit your changes (`git commit -m 'Add amazing feature'`)
 4. Push to the branch (`git push origin feature/amazing-feature`)
 5. Open a Pull Request
 ### Development Guidelines
 - Write tests for new features
 - Follow PEP 8 style guide
 - Add type hints to all functions
 - Keep line length ≤ 79 characters
 - Run `mypy` and `ruff` before committing
 ## 📝 License
 This project is licensed under the MIT License - see the LICENSE file for details.
 ## 🙏 Acknowledgments
 - Built with [FastAPI](https://fastapi.tiangolo.com/)
 - Package management by [uv](https://github.com/astral-sh/uv)
 - Containerization with [Docker](https://www.docker.com/)
 ## 📧 Contact
 Brian Bjarke Jensen - [@brian](https://gitea.gt-proj.com/brian)
 Project Link: [https://gitea.gt-proj.com/brian/baby-monitor](https://gitea.gt-proj.com/brian/baby-monitor)
 ---
 Made with ❤️ for new parents everywhere
@@ -0,0 +1,60 @@
 services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8000:8000"
    volumes:
      # Persist database to local directory
      - ./data:/data
    environment:
      # Set environment to production
      - ENVIRONMENT=production
      # Set admin credentials
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=password
      # Use Redis for token storage
      - REDIS_URI=redis://redis:6379/0
      # Use PostgreSQL for database
      - DATABASE_URL=postgresql://baby_monitor:securepassword@postgres:5432/baby_monitor_db
    command: ["--host", "0.0.0.0", "--port", "8000"]
    restart: unless-stopped
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 1s
  postgres:
    image: postgres:14-alpine
    environment:
      - POSTGRES_USER=baby_monitor
      - POSTGRES_PASSWORD=securepassword
      - POSTGRES_DB=baby_monitor_db
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U baby_monitor -d baby_monitor_db"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
 volumes:
  redis-data:
  pgdata:
@@ -1,5 +1,3 @@
 version: "3.8"
 services:
  app:
    build:
@@ -10,7 +8,13 @@ services:
    volumes:
      # Mount source code for hot-reloading during development
      - ./src:/app/src:ro
      # Persist database to local directory
      - ./data:/data
    environment:
      # Set environment to development for hot-reloading and debug features
      - ENVIRONMENT=development
      # Optional: Override admin credentials for development
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=password
    command: ["--host", "0.0.0.0", "--port", "8000", "--reload"]
    restart: unless-stopped
@@ -0,0 +1,186 @@
 # Baby Monitor - Self-Contained Docker Image
 This Docker image is a self-contained service ready for deployment with all optional dependencies pre-installed.
 ## Quick Start
 ```bash
 docker run -p 8000:8000 baby-monitor
 ```
 Access the application at `http://localhost:8000`
 ## Features
 This image includes all optional dependencies:
 - ✅ **Redis** support for distributed token storage
 - ✅ **PostgreSQL** support for scalable database backend
 - ✅ **SQLite** built-in for single-instance deployments
 ## Configuration
 Configure the service using environment variables:
 ### Basic Configuration
 | Variable         | Default      | Description                             |
 | ---------------- | ------------ | --------------------------------------- |
 | `ENVIRONMENT`    | `production` | Set to `development` to enable API docs |
 | `DATA_DIR`       | `/data`      | Directory for SQLite database           |
 | `ADMIN_USERNAME` | `admin`      | Admin username                          |
 | `ADMIN_PASSWORD` | _(required)_ | Admin password (required in production) |
 ### Redis Configuration (Optional)
 | Variable    | Description                                         |
 | ----------- | --------------------------------------------------- |
 | `REDIS_URI` | Redis connection URI (e.g., `redis://redis:6379/0`) |
 When `REDIS_URI` is set, the application uses Redis for token storage instead of in-memory storage.
 ### PostgreSQL Configuration (Optional)
 _Coming soon_
 ## Examples
 ### Basic Deployment
 ```bash
 docker run -d \
  -p 8000:8000 \
  -e ADMIN_PASSWORD=your_secure_password \
  -v ./data:/data \
  baby-monitor
 ```
 ### With Redis
 ```bash
 # Start Redis
 docker run -d --name redis redis:7-alpine
 # Start Baby Monitor with Redis
 docker run -d \
  -p 8000:8000 \
  -e ADMIN_PASSWORD=your_secure_password \
  -e REDIS_URI=redis://redis:6379/0 \
  --link redis \
  baby-monitor
 ```
 ### Using Docker Compose
 ```yaml
 version: "3.8"
 services:
  app:
    image: baby-monitor
    ports:
      - "8000:8000"
    environment:
      - ADMIN_PASSWORD=your_secure_password
      - REDIS_URI=redis://redis:6379/0
    volumes:
      - ./data:/data
    depends_on:
      - redis
  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
 volumes:
  redis-data:
 ```
 ## Health Checks
 The image provides several endpoints for monitoring:
 - `GET /health` - Basic health check (returns `{"status": "healthy"}`)
 - `GET /ready` - Readiness check for orchestration
 - `GET /info` - Service information including installed features
 Example:
 ```bash
 curl http://localhost:8000/info
 ```
 Response:
 ```json
 {
  "service": "baby-monitor",
  "version": "0.1.0",
  "features": {
    "redis": true,
    "postgresql": true
  },
  "config": {
    "environment": "production",
    "data_dir": "/data",
    "redis_configured": true
  }
 }
 ```
 ## Volumes
 - `/data` - Persistent storage for SQLite database
 Mount this directory to preserve data across container restarts:
 ```bash
 docker run -v /path/on/host:/data baby-monitor
 ```
 ## Ports
 - `8000` - HTTP API server
 ## Security Notes
 1. **Always set `ADMIN_PASSWORD`** in production
 2. Use **strong passwords** (minimum 16 characters)
 3. Run behind a **reverse proxy** with HTTPS
 4. Use **Redis** for multi-instance deployments
 5. **Back up** the `/data` directory regularly
 ## Troubleshooting
 ### Check installed features
 ```bash
 curl http://localhost:8000/info
 ```
 ### View logs
 ```bash
 docker logs <container-name>
 ```
 ### Verify Redis connection
 Look for startup message:
 ```bash
 ✓ Connected to Redis at redis://...
 ```
 ### Test authentication
 ```bash
 curl -X POST http://localhost:8000/api/login \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"your_password"}'
 ```
 ## Support
 For issues and feature requests, please visit the project repository.
@@ -0,0 +1,89 @@
 # Token Storage Configuration
 The application automatically detects and uses the appropriate token storage backend based on environment variables.
 ## In-Memory Storage (Default)
 By default, tokens are stored in memory. This is suitable for:
 - Development
 - Single-instance deployments
 - Testing
 **No configuration needed** - this is the default behavior.
 ## Redis Storage (Production Recommended)
 For production deployments with multiple instances, use Redis for shared token storage.
 ### Setup
 1. **Install Redis dependency:**
   ```bash
   uv sync --extra redis
   # or
   pip install redis>=5.0.0
   ```
 2. **Set environment variable:**
   ```bash
   export REDIS_URI=redis://localhost:6379/0
   ```
 3. **Start the application:**
   The app will automatically detect Redis and use it for token storage.
 ### Docker Compose with Redis
 Uncomment the Redis service in `docker-compose.yml`:
 ```yaml
 services:
  app:
    environment:
      - REDIS_URI=redis://redis:6379/0
  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
 volumes:
  redis-data:
 ```
 Then run:
 ```bash
 docker compose up
 ```
 ### Verification
 On startup, the application will print:
 - `✓ Connected to Redis at redis://...` - Using Redis
 - `ℹ Using in-memory token storage` - Using in-memory
 ### Error Handling
 **Important**: If `REDIS_URI` is set, the application **requires** a successful Redis connection. It will **not** fall back to in-memory storage.
 If Redis connection fails, the application will exit with a clear error message:
 ```
 RuntimeError: Failed to connect to Redis at redis://localhost:6379.
 Ensure Redis is running and accessible.
 ```
 This prevents silent failures in production environments where Redis is expected.
 ### Benefits of Redis
 - ✅ **Shared storage** across multiple app instances
 - ✅ **Automatic expiration** with TTL
 - ✅ **Persistent** (with proper Redis configuration)
 - ✅ **Scalable** for high-traffic applications
 - ✅ **Drop-in replacement** - no code changes needed
@@ -5,10 +5,20 @@ description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
    "bcrypt>=4.0.0",
    "fastapi>=0.121.0",
    "sqlalchemy>=2.0.0",
    "uvicorn>=0.38.0",
 ]
 [project.optional-dependencies]
 redis = [
    "redis>=5.0.0",
 ]
 postgres = [
    "psycopg2-binary>=2.9.0",
 ]
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -21,10 +31,12 @@ dev = [
    "httpx>=0.28.1",
    "mypy>=1.18.2",
    "pre-commit>=4.3.0",
    "prettier>=0.0.7",
    "pytest>=8.4.2",
    "pytest-cov>=7.0.0",
    "pyupgrade>=3.21.0",
    "ruff>=0.14.3",
    "types-psycopg2>=2.9.21.20251012",
 ]
 [[tool.uv.index]]
@@ -55,3 +67,7 @@ markers = [
    "unit: marks tests as unit tests",
    "integration: marks tests as integration tests",
 ]
 [[tool.mypy.overrides]]
 module = "redis.*"
 ignore_missing_imports = true
@@ -1,7 +1,22 @@
 """Baby Monitor Main Application"""
 import os
-from fastapi import FastAPI
+from pathlib import Path
 from typing import Annotated
 from contextlib import asynccontextmanager
 from collections.abc import AsyncIterator
 from fastapi import FastAPI, Depends
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 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.diaper_change import router as diaper_change_router
 from baby_monitor.routers.health import router as health_router
 from baby_monitor.repositories.dependencies.get_database import init_db
 # Disable docs in production
 ENVIRONMENT = os.getenv("ENVIRONMENT", "production")
@@ -9,37 +24,94 @@ docs_url = "/docs" if ENVIRONMENT == "development" else None
 redoc_url = "/redoc" if ENVIRONMENT == "development" else None
 openapi_url = "/openapi.json" if ENVIRONMENT == "development" else None
@asynccontextmanager
 async def lifespan(app_instance: FastAPI) -> AsyncIterator[None]:
    """Lifespan event handler for startup and shutdown."""
    # Startup: Initialize database tables
    init_db()
    yield
    # Shutdown: Add cleanup code here if needed
 # Instantiate app
 app = FastAPI(
    docs_url=docs_url,
    redoc_url=redoc_url,
    openapi_url=openapi_url,
    lifespan=lifespan,
 )
-@app.get("/")
+# Mount static files
-def read_root() -> dict:
+static_path = Path(__file__).parent / "static"
-    """Root endpoint returning a welcome message."""
+app.mount("/static", StaticFiles(directory=str(static_path)), name="static")
-    return {"message": "Hello World"}
+
 # Include routers
 app.include_router(auth_router)
 app.include_router(admin_router)
 app.include_router(child_router)
 app.include_router(feeding_router)
 app.include_router(diaper_change_router)
 app.include_router(health_router)
-@app.get("/health")
+# Serve HTML pages at root level
-def health_check() -> dict[str, str]:
+@app.get("/", include_in_schema=False)
-    """
+def serve_home() -> FileResponse:
-    Health check endpoint for container orchestration.
+    """Serve the home page (handles auth check client-side)."""
-
+    return FileResponse(static_path / "index.html")
    Returns 200 if the service is alive and able to handle requests.
    """
    return {"status": "healthy"}
-@app.get("/ready")
+@app.get("/login.html", include_in_schema=False)
-def readiness_check() -> dict[str, str]:
+def serve_login() -> FileResponse:
-    """
+    """Serve the login page."""
-    Readiness check endpoint for container orchestration.
+    return FileResponse(static_path / "login.html")
-    Returns 200 if the service is ready to accept traffic.
+
-    This can include checks for database connectivity, external services, etc.
+@app.get("/register.html", include_in_schema=False)
-    """
+def serve_register() -> FileResponse:
-    # Add dependency checks here if needed (database, cache, etc.)
+    """Serve the registration page."""
-    # For now, simple readiness check
+    return FileResponse(static_path / "register.html")
-    return {"status": "ready"}
+
@app.get("/admin.html", include_in_schema=False)
 def serve_admin() -> FileResponse:
    """Serve the admin page."""
    return FileResponse(static_path / "admin.html")
@app.get("/add-child.html", include_in_schema=False)
 def serve_add_child() -> FileResponse:
    """Serve the add child page."""
    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("/feedings.html", include_in_schema=False)
 def serve_feedings() -> FileResponse:
    """Serve the feedings overview page."""
    return FileResponse(static_path / "feedings.html")
@app.get("/diapers.html", include_in_schema=False)
 def serve_diapers() -> FileResponse:
    """Serve the diaper changes overview page."""
    return FileResponse(static_path / "diapers.html")
@app.get("/log-diaper.html", include_in_schema=False)
 def serve_log_diaper() -> FileResponse:
    """Serve the log diaper change page."""
    return FileResponse(static_path / "log-diaper.html")
@app.get("/api/")
 def read_root(token: Annotated[str, Depends(verify_token)]) -> dict:
    """API root endpoint (requires authentication)."""
    return {"message": "Hello World", "authenticated": True}
@@ -0,0 +1,3 @@
 from .auth import LoginRequest, LoginResponse
 __all__ = ["LoginRequest", "LoginResponse"]
@@ -0,0 +1,38 @@
 """Authentication models for request and response validation."""
 from pydantic import BaseModel
 class LoginRequest(BaseModel):
    """Request model for user login."""
    username: str
    password: str
 class LoginResponse(BaseModel):
    """Response model for successful login."""
    message: str
    username: str
    access_token: str
    is_admin: bool
    token_type: str = "bearer"
 class RegisterRequest(BaseModel):
    """Request model for user registration."""
    username: str
    password: str
    invitation_token: str
 class RegisterResponse(BaseModel):
    """Response model for successful registration."""
    message: str
    username: str
    access_token: str
    is_admin: bool
    token_type: str = "bearer"
@@ -0,0 +1,23 @@
 """Child-related request and response models."""
 from datetime import datetime
 from pydantic import BaseModel, Field
 class CreateChildRequest(BaseModel):
    """Request model for creating a child."""
    name: str = Field(..., min_length=1, max_length=100)
    birth_time: datetime
    birth_weight: float = Field(..., gt=0, description="Birth weight in grams")
 class ChildResponse(BaseModel):
    """Response model for child data."""
    id: int
    name: str
    birth_time: datetime
    birth_weight: float
    user_id: int
    created_at: datetime
@@ -0,0 +1,5 @@
 """Database models package."""
 from baby_monitor.models.db.user import User
 __all__ = ["User"]
@@ -0,0 +1,28 @@
 """Child database model."""
 from typing import TYPE_CHECKING
 from sqlalchemy import Column, Integer, String, DateTime, Float, ForeignKey
 from datetime import datetime
 if TYPE_CHECKING:
    from sqlalchemy.orm import DeclarativeBase
    Base = DeclarativeBase
 else:
    from baby_monitor.repositories.dependencies.get_database import Base
 class Child(Base):
    """Child database model."""
    __tablename__ = "children"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, nullable=False)
    birth_time = Column(DateTime, nullable=False)
    birth_weight = Column(Float, nullable=False)  # in grams
    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
    def __repr__(self) -> str:
        return f"<Child(id={self.id}, name='{self.name}', user_id={self.user_id})>"
@@ -0,0 +1,30 @@
 """Diaper change 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 DiaperChange(Base):
    """Diaper change log database model."""
    __tablename__ = "diaper_changes"
    id = Column(Integer, primary_key=True, index=True)
    child_id = Column(Integer, ForeignKey("children.id"), nullable=False)
    change_time = Column(DateTime, nullable=False)
    poop_amount = Column(String, nullable=True)  # stores PoopAmount enum
    poop_color = Column(String, nullable=True)  # stores PoopColor enum
    pee_amount = Column(String, nullable=True)  # stores PeeAmount enum
    pee_color = Column(String, nullable=True)  # stores PeeColor enum
    created_at = Column(DateTime, default=datetime.now(UTC), nullable=False)
    def __repr__(self) -> str:
        return f"<DiaperChange(id={self.id}, child_id={self.child_id})>"
@@ -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})>"
@@ -0,0 +1,27 @@
 """Database models."""
 from typing import TYPE_CHECKING
 from sqlalchemy import Column, Integer, String, DateTime, Boolean
 from datetime import datetime
 if TYPE_CHECKING:
    from sqlalchemy.orm import DeclarativeBase
    Base = DeclarativeBase
 else:
    from baby_monitor.repositories.dependencies.get_database import Base
 class User(Base):
    """User database model."""
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True, nullable=False)
    hashed_password = Column(String, nullable=False)
    is_admin = Column(Boolean, default=False, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
    def __repr__(self) -> str:
        return f"<User(id={self.id}, username='{self.username}')>"
@@ -0,0 +1,46 @@
 """Diaper change-related request and response models."""
 from datetime import datetime
 from pydantic import BaseModel, Field
 from baby_monitor.models.enums import (
    PeeAmount,
    PeeColor,
    PoopAmount,
    PoopColor,
 )
 class CreateDiaperChangeRequest(BaseModel):
    """Request model for creating a diaper change log."""
    child_id: int = Field(..., gt=0)
    change_time: datetime
    poop_amount: PoopAmount | None = None
    poop_color: PoopColor | None = None
    pee_amount: PeeAmount | None = None
    pee_color: PeeColor | None = None
 class UpdateDiaperChangeRequest(BaseModel):
    """Request model for updating a diaper change log."""
    change_time: datetime | None = None
    poop_amount: PoopAmount | None = None
    poop_color: PoopColor | None = None
    pee_amount: PeeAmount | None = None
    pee_color: PeeColor | None = None
 class DiaperChangeResponse(BaseModel):
    """Response model for diaper change log data."""
    id: int
    child_id: int
    change_time: datetime
    poop_amount: str | None
    poop_color: str | None
    pee_amount: str | None
    pee_color: str | None
    created_at: datetime
    child_name: str | None = None  # Optional, populated when needed
@@ -0,0 +1,44 @@
 """Feeding type enumeration."""
 from enum import StrEnum
 class FeedingType(StrEnum):
    """Enumeration of feeding types."""
    LEFT_BREAST = "left_breast"
    RIGHT_BREAST = "right_breast"
    BOTTLE = "bottle"
 class PoopAmount(StrEnum):
    """Enumeration of poop amounts."""
    LIGHT = "light"
    MEDIUM = "medium"
    HEAVY = "heavy"
 class PoopColor(StrEnum):
    """Enumeration of poop colors."""
    BLACK = "black"
    YELLOW = "yellow"
    GREEN = "green"
    BROWN = "brown"
 class PeeAmount(StrEnum):
    """Enumeration of pee amounts."""
    LIGHT = "light"
    MEDIUM = "medium"
    HEAVY = "heavy"
 class PeeColor(StrEnum):
    """Enumeration of pee colors."""
    CLEAR = "clear"
    YELLOW = "yellow"
    RED = "red"
@@ -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
@@ -0,0 +1,37 @@
 """Invitation token model for user registration.
 Note: DateTime(timezone=True) is used for PostgreSQL compatibility.
 SQLite will store as naive UTC, which is handled in the repository layer.
 """
 from datetime import datetime
 from typing import TYPE_CHECKING
 from sqlalchemy import Boolean, DateTime, Integer, String
 from sqlalchemy.orm import Mapped, mapped_column
 if TYPE_CHECKING:
    from sqlalchemy.orm import DeclarativeBase
    Base = DeclarativeBase
 else:
    from baby_monitor.repositories.dependencies.get_database import Base
 class Invitation(Base):
    """Invitation token for new user registration."""
    __tablename__ = "invitations"
    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    token: Mapped[str] = mapped_column(String, unique=True, nullable=False)
    created_at: Mapped[datetime] = mapped_column(
        DateTime(timezone=True), nullable=False
    )
    expires_at: Mapped[datetime] = mapped_column(
        DateTime(timezone=True), nullable=False
    )
    created_by_user_id: Mapped[int] = mapped_column(Integer, nullable=False)
    is_consumed: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
    consumed_at: Mapped[datetime | None] = mapped_column(
        DateTime(timezone=True), nullable=True
    )
@@ -0,0 +1,13 @@
 """Repository implementations package."""
 from baby_monitor.repositories.dependencies import (
    get_credentials_repository,
    get_token_repository,
    get_user_repository,
 )
 __all__ = [
    "get_credentials_repository",
    "get_token_repository",
    "get_user_repository",
 ]
@@ -0,0 +1,111 @@
 """SQLite implementation of child repository."""
 from datetime import datetime
 from sqlalchemy.orm import Session
 from baby_monitor.repositories.interfaces.child_repository_interface import (
    ChildRepositoryInterface,
 )
 from baby_monitor.models.db.child import Child
 class SQLiteChildRepository(ChildRepositoryInterface):
    """SQLite implementation for child data access."""
    def __init__(self, db: Session):
        self.db = db
    def create(
        self, name: str, birth_time: datetime, birth_weight: float, user_id: int
    ) -> dict:
        """Create a new child record."""
        child = Child(
            name=name,
            birth_time=birth_time,
            birth_weight=birth_weight,
            user_id=user_id,
        )
        self.db.add(child)
        self.db.commit()
        self.db.refresh(child)
        return {
            "id": child.id,
            "name": child.name,
            "birth_time": child.birth_time,
            "birth_weight": child.birth_weight,
            "user_id": child.user_id,
            "created_at": child.created_at,
        }
    def get_by_id(self, child_id: int) -> dict | None:
        """Get a child by ID."""
        child = self.db.query(Child).filter(Child.id == child_id).first()
        if not child:
            return None
        return {
            "id": child.id,
            "name": child.name,
            "birth_time": child.birth_time,
            "birth_weight": child.birth_weight,
            "user_id": child.user_id,
            "created_at": child.created_at,
        }
    def get_by_user_id(self, user_id: int) -> list[dict]:
        """Get all children for a specific user."""
        children = self.db.query(Child).filter(Child.user_id == user_id).all()
        return [
            {
                "id": child.id,
                "name": child.name,
                "birth_time": child.birth_time,
                "birth_weight": child.birth_weight,
                "user_id": child.user_id,
                "created_at": child.created_at,
            }
            for child in children
        ]
    def update(
        self,
        child_id: int,
        name: str | None = None,
        birth_time: datetime | None = None,
        birth_weight: float | None = None,
    ) -> dict | None:
        """Update a child record."""
        child = self.db.query(Child).filter(Child.id == child_id).first()
        if not child:
            return None
        if name is not None:
            child.name = name  # type: ignore[assignment]
        if birth_time is not None:
            child.birth_time = birth_time  # type: ignore[assignment]
        if birth_weight is not None:
            child.birth_weight = birth_weight  # type: ignore[assignment]
        self.db.commit()
        self.db.refresh(child)
        return {
            "id": child.id,
            "name": child.name,
            "birth_time": child.birth_time,
            "birth_weight": child.birth_weight,
            "user_id": child.user_id,
            "created_at": child.created_at,
        }
    def delete(self, child_id: int) -> bool:
        """Delete a child record."""
        child = self.db.query(Child).filter(Child.id == child_id).first()
        if not child:
            return False
        self.db.delete(child)
        self.db.commit()
        return True
@@ -0,0 +1,37 @@
 """Environment-based credentials repository."""
 import os
 from baby_monitor.repositories.interfaces import CredentialsRepositoryInterface
 class EnvCredentialsRepository(CredentialsRepositoryInterface):
    """
    Credentials repository that reads from environment variables.
    Environment variables:
    - ADMIN_USERNAME: Admin username (default: "admin")
    - ADMIN_PASSWORD: Admin password (required in production)
    """
    def __init__(self) -> None:
        self.admin_username = os.getenv("ADMIN_USERNAME", "admin")
        self.admin_password = os.getenv("ADMIN_PASSWORD")
        # Warn if using default password in production
        env = os.getenv("ENVIRONMENT", "production")
        if env == "production" and not self.admin_password:
            raise ValueError(
                "ADMIN_PASSWORD environment variable must be set in production"
            )
        # Use default for development
        if not self.admin_password:
            self.admin_password = "password"
    def verify_admin_credentials(self, username: str, password: str) -> bool:
        """Verify admin username and password."""
        return username == self.admin_username and password == self.admin_password
    def get_admin_username(self) -> str:
        """Get the admin username."""
        return self.admin_username
@@ -0,0 +1,11 @@
 """Dependency injection for repositories."""
 from .get_credentials_repository import get_credentials_repository
 from .get_token_repository import get_token_repository
 from .get_user_repository import get_user_repository
 __all__ = [
    "get_user_repository",
    "get_token_repository",
    "get_credentials_repository",
 ]
@@ -0,0 +1,15 @@
 """Dependency for getting child 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.child.sqlite_child import SQLiteChildRepository
 def get_child_repository(
    db: Annotated[Session, Depends(get_database)],
 ) -> SQLiteChildRepository:
    """Get child repository instance."""
    return SQLiteChildRepository(db)
@@ -0,0 +1,44 @@
 """Definition of get_credentials_repository dependency."""
 import logging
 from baby_monitor.repositories.interfaces import (
    CredentialsRepositoryInterface,
 )
 from baby_monitor.repositories.credentials.env_credentials import (
    EnvCredentialsRepository,
 )
 # Singleton instance
 _credentials_repository: CredentialsRepositoryInterface | None = None
 def _initialize_credentials_repository() -> CredentialsRepositoryInterface:
    """
    Initialize credentials repository based on environment.
    Currently uses environment variables.
    Can be extended to support:
    - Database-backed credentials
    - External secret managers (AWS Secrets Manager, HashiCorp Vault)
    - LDAP/Active Directory
    """
    # Setup logger
    logger = logging.getLogger(__name__)
    logger.info("Using environment variable based credentials repository")
    return EnvCredentialsRepository()
 def get_credentials_repository() -> CredentialsRepositoryInterface:
    """
    Get credentials repository instance.
    """
    global _credentials_repository
    if _credentials_repository is None:
        _credentials_repository = _initialize_credentials_repository()
    return _credentials_repository
@@ -0,0 +1,103 @@
 """Database configuration and session management."""
 import os
 from pathlib import Path
 from collections.abc import Generator
 from typing import TYPE_CHECKING
 from sqlalchemy import create_engine
 from sqlalchemy.orm import declarative_base, sessionmaker, Session
 if TYPE_CHECKING:
    from sqlalchemy.orm import DeclarativeBase
 # Database directory
 DATA_DIR = Path(os.getenv("DATA_DIR", "/data"))
 # SQLite database URL
 DATABASE_URL = f"sqlite:///{DATA_DIR}/baby_monitor.db"
 # Create engine with check_same_thread=False for SQLite
 engine = create_engine(
    DATABASE_URL,
    connect_args={"check_same_thread": False},
    echo=False,  # Set to True for SQL query logging
 )
 # Session factory
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 # Base class for declarative models
 Base: "type[DeclarativeBase]" = declarative_base()
 def _ensure_admin_user() -> None:
    """Create or update admin user from environment variables."""
    from baby_monitor.models.db.user import User
    from baby_monitor.utils.password import hash_password
    admin_username = os.getenv("ADMIN_USERNAME")
    admin_password = os.getenv("ADMIN_PASSWORD")
    if not admin_username:
        raise RuntimeError(
            "ADMIN_USERNAME environment variable is required but not set"
        )
    if not admin_password:
        raise RuntimeError(
            "ADMIN_PASSWORD environment variable is required but not set"
        )
    db = SessionLocal()
    try:
        # Check if admin user exists
        admin_user = db.query(User).filter(User.username == admin_username).first()
        hashed_pw = hash_password(admin_password)
        if admin_user:
            # Update existing admin user's password and ensure admin flag
            admin_user.hashed_password = hashed_pw  # type: ignore[assignment]
            admin_user.is_admin = True  # type: ignore[assignment]
            db.commit()
        else:
            # Create new admin user
            new_admin = User(
                username=admin_username,
                hashed_password=hashed_pw,
                is_admin=True,
            )
            db.add(new_admin)
            db.commit()
    finally:
        db.close()
 def init_db() -> None:
    """Initialize the database by creating all tables."""
    # Import models to register them with Base.metadata
    # 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.db.diaper_change import DiaperChange  # noqa: F401
    from baby_monitor.models.invitation import Invitation  # noqa: F401
    # Ensure data directory exists
    DATA_DIR.mkdir(parents=True, exist_ok=True)
    Base.metadata.create_all(bind=engine)
    # Create admin user if it doesn't exist
    _ensure_admin_user()
 def get_database() -> Generator[Session, None, None]:
    """
    Dependency that provides a database session.
    Yields a database session and ensures it's closed after use.
    """
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()
@@ -0,0 +1,17 @@
 """Dependency for getting diaper change 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.diaper_change.sqlite_diaper_change import (
    SQLiteDiaperChangeRepository,
 )
 def get_diaper_change_repository(
    db: Annotated[Session, Depends(get_database)],
 ) -> SQLiteDiaperChangeRepository:
    """Get diaper change repository instance."""
    return SQLiteDiaperChangeRepository(db)
@@ -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)
@@ -0,0 +1,25 @@
 """Dependency injection for invitation repository."""
 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.invitation.sqlite_invitation import (
    SQLiteInvitationRepository,
 )
 def get_invitation_repository(
    db: Annotated[Session, Depends(get_database)],
 ) -> SQLiteInvitationRepository:
    """
    Provide an invitation repository instance.
    Args:
        db: Database session from dependency injection
    Returns:
        SQLiteInvitationRepository instance
    """
    return SQLiteInvitationRepository(db)
@@ -0,0 +1,77 @@
 """Definition of get_token_repository dependency."""
 import os
 import logging
 from baby_monitor.repositories.interfaces import (
    TokenRepositoryInterface,
 )
 from baby_monitor.repositories.token.memory_token import (
    InMemoryTokenRepository,
 )
 # Singleton instance
 _token_repository: TokenRepositoryInterface | None = None
 def _initialize_token_repository() -> TokenRepositoryInterface:
    """
    Initialize token repository based on environment.
    Uses Redis if REDIS_URI is set, otherwise uses in-memory storage.
    Raises exception if REDIS_URI is set but connection fails.
    """
    # Setup logger
    logger = logging.getLogger(__name__)
    # Check for REDIS_URI environment variable
    redis_uri = os.getenv("REDIS_URI")
    # Use in-memory token repository if REDIS_URI is not set
    if not redis_uri:
        logger.info("Using in-memory token storage")
        return InMemoryTokenRepository()
    # Attempt to use RedisTokenRepository
    try:
        import redis
    except ImportError as e:
        raise RuntimeError(
            "REDIS_URI is set but redis package is not installed. "
            "Install with: uv sync --extra redis"
        ) from e
    try:
        from baby_monitor.repositories.token.redis_token import (
            RedisTokenRepository,
        )
        redis_client = redis.from_url(redis_uri)
        # Test connection
        redis_client.ping()
        logger.info(f"Connected to Redis at {redis_uri}")
        return RedisTokenRepository(redis_client)
    except redis.ConnectionError as e:
        raise RuntimeError(
            f"Failed to connect to Redis at {redis_uri}. "
            f"Ensure Redis is running and accessible. Error: {e}"
        ) from e
    except Exception as e:
        raise RuntimeError(f"Failed to initialize Redis token repository: {e}") from e
 def get_token_repository() -> TokenRepositoryInterface:
    """
    Get token repository instance.
    Automatically uses Redis if REDIS_URI environment variable is set,
    otherwise falls back to in-memory storage.
    """
    global _token_repository
    if _token_repository is None:
        _token_repository = _initialize_token_repository()
    return _token_repository
@@ -0,0 +1,33 @@
 """Definition of get_user_repository dependency."""
 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.interfaces import (
    UserRepositoryInterface,
 )
 from baby_monitor.repositories.user.sqlite_user import (
    SQLiteUserRepository,
 )
 # Singleton instance
 _user_repository: UserRepositoryInterface | None = None
 def get_user_repository(
    db: Annotated[Session, Depends(get_database)],
 ) -> UserRepositoryInterface:
    """
    Get user repository instance.
    """
    global _user_repository
    if _user_repository is None:
        _user_repository = SQLiteUserRepository(db)
    return _user_repository
@@ -0,0 +1,133 @@
 """SQLite implementation of diaper change repository."""
 from datetime import datetime
 from sqlalchemy.orm import Session
 from baby_monitor.repositories.interfaces.diaper_change_repository_interface import (  # noqa: E501
    DiaperChangeRepositoryInterface,
 )
 from baby_monitor.models.db.diaper_change import DiaperChange
 from baby_monitor.models.db.child import Child
 class SQLiteDiaperChangeRepository(DiaperChangeRepositoryInterface):
    """SQLite implementation for diaper change log data access."""
    def __init__(self, db: Session):
        self.db = db
    def create(
        self,
        child_id: int,
        change_time: datetime,
        poop_amount: str | None = None,
        poop_color: str | None = None,
        pee_amount: str | None = None,
        pee_color: str | None = None,
    ) -> dict:
        """Create a new diaper change log entry."""
        diaper_change = DiaperChange(
            child_id=child_id,
            change_time=change_time,
            poop_amount=poop_amount,
            poop_color=poop_color,
            pee_amount=pee_amount,
            pee_color=pee_color,
        )
        self.db.add(diaper_change)
        self.db.commit()
        self.db.refresh(diaper_change)
        return self._to_dict(diaper_change)
    def get_by_id(self, diaper_change_id: int) -> dict | None:
        """Get a diaper change log by ID."""
        diaper_change = (
            self.db.query(DiaperChange)
            .filter(DiaperChange.id == diaper_change_id)
            .first()
        )
        if not diaper_change:
            return None
        return self._to_dict(diaper_change)
    def get_by_child_id(self, child_id: int) -> list[dict]:
        """Get all diaper change logs for a specific child."""
        diaper_changes = (
            self.db.query(DiaperChange)
            .filter(DiaperChange.child_id == child_id)
            .order_by(DiaperChange.change_time.desc())
            .all()
        )
        return [self._to_dict(dc) for dc in diaper_changes]
    def get_by_user_id(self, user_id: int) -> list[dict]:
        """Get all diaper change logs for a specific user's children."""
        diaper_changes = (
            self.db.query(DiaperChange)
            .join(Child)
            .filter(Child.user_id == user_id)
            .order_by(DiaperChange.change_time.desc())
            .all()
        )
        return [self._to_dict(dc) for dc in diaper_changes]
    def update(
        self,
        diaper_change_id: int,
        change_time: datetime | None = None,
        poop_amount: str | None = None,
        poop_color: str | None = None,
        pee_amount: str | None = None,
        pee_color: str | None = None,
    ) -> dict | None:
        """Update a diaper change log entry."""
        diaper_change = (
            self.db.query(DiaperChange)
            .filter(DiaperChange.id == diaper_change_id)
            .first()
        )
        if not diaper_change:
            return None
        if change_time is not None:
            diaper_change.change_time = change_time  # type: ignore[assignment]
        if poop_amount is not None:
            diaper_change.poop_amount = poop_amount  # type: ignore[assignment]
        if poop_color is not None:
            diaper_change.poop_color = poop_color  # type: ignore[assignment]
        if pee_amount is not None:
            diaper_change.pee_amount = pee_amount  # type: ignore[assignment]
        if pee_color is not None:
            diaper_change.pee_color = pee_color  # type: ignore[assignment]
        self.db.commit()
        self.db.refresh(diaper_change)
        return self._to_dict(diaper_change)
    def delete(self, diaper_change_id: int) -> bool:
        """Delete a diaper change log entry."""
        diaper_change = (
            self.db.query(DiaperChange)
            .filter(DiaperChange.id == diaper_change_id)
            .first()
        )
        if not diaper_change:
            return False
        self.db.delete(diaper_change)
        self.db.commit()
        return True
    def _to_dict(self, diaper_change: DiaperChange) -> dict:
        """Convert DiaperChange model to dictionary."""
        return {
            "id": diaper_change.id,
            "child_id": diaper_change.child_id,
            "change_time": diaper_change.change_time,
            "poop_amount": diaper_change.poop_amount,
            "poop_color": diaper_change.poop_color,
            "pee_amount": diaper_change.pee_amount,
            "pee_color": diaper_change.pee_color,
            "created_at": diaper_change.created_at,
        }
@@ -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,
        }
@@ -0,0 +1,21 @@
 """Repository interfaces package."""
 from .credentials_repository_interface import (
    CredentialsRepositoryInterface,
 )
 from .invitation_repository_interface import (
    InvitationRepositoryInterface,
 )
 from .token_repository_interface import (
    TokenRepositoryInterface,
 )
 from .user_repository_interface import (
    UserRepositoryInterface,
 )
 __all__ = [
    "UserRepositoryInterface",
    "TokenRepositoryInterface",
    "CredentialsRepositoryInterface",
    "InvitationRepositoryInterface",
 ]
@@ -0,0 +1,36 @@
 """Interface for child repository operations."""
 from abc import ABC, abstractmethod
 from datetime import datetime
 class ChildRepositoryInterface(ABC):
    """Interface for child data access operations."""
    @abstractmethod
    def create(
        self, name: str, birth_time: datetime, birth_weight: float, user_id: int
    ) -> dict:
        """Create a new child record."""
    @abstractmethod
    def get_by_id(self, child_id: int) -> dict | None:
        """Get a child by ID."""
    @abstractmethod
    def get_by_user_id(self, user_id: int) -> list[dict]:
        """Get all children for a specific user."""
    @abstractmethod
    def update(
        self,
        child_id: int,
        name: str | None = None,
        birth_time: datetime | None = None,
        birth_weight: float | None = None,
    ) -> dict | None:
        """Update a child record."""
    @abstractmethod
    def delete(self, child_id: int) -> bool:
        """Delete a child record."""
@@ -0,0 +1,15 @@
 """Definition of CredentialsRepositoryInterface."""
 from abc import ABC, abstractmethod
 class CredentialsRepositoryInterface(ABC):
    """Interface for credentials/secrets management."""
    @abstractmethod
    def verify_admin_credentials(self, username: str, password: str) -> bool:
        """Verify admin username and password."""
    @abstractmethod
    def get_admin_username(self) -> str:
        """Get the admin username."""
@@ -0,0 +1,48 @@
 """Interface for diaper change repository operations."""
 from abc import ABC, abstractmethod
 from datetime import datetime
 class DiaperChangeRepositoryInterface(ABC):
    """Interface for diaper change log data access operations."""
    @abstractmethod
    def create(
        self,
        child_id: int,
        change_time: datetime,
        poop_amount: str | None = None,
        poop_color: str | None = None,
        pee_amount: str | None = None,
        pee_color: str | None = None,
    ) -> dict:
        """Create a new diaper change log entry."""
    @abstractmethod
    def get_by_id(self, diaper_change_id: int) -> dict | None:
        """Get a diaper change log by ID."""
    @abstractmethod
    def get_by_child_id(self, child_id: int) -> list[dict]:
        """Get all diaper change logs for a specific child."""
    @abstractmethod
    def get_by_user_id(self, user_id: int) -> list[dict]:
        """Get all diaper change logs for a specific user's children."""
    @abstractmethod
    def update(
        self,
        diaper_change_id: int,
        change_time: datetime | None = None,
        poop_amount: str | None = None,
        poop_color: str | None = None,
        pee_amount: str | None = None,
        pee_color: str | None = None,
    ) -> dict | None:
        """Update a diaper change log entry."""
    @abstractmethod
    def delete(self, diaper_change_id: int) -> bool:
        """Delete a diaper change log entry."""
@@ -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."""
@@ -0,0 +1,49 @@
 """Interface for invitation repository operations."""
 from abc import ABC, abstractmethod
 from datetime import datetime
 class InvitationRepositoryInterface(ABC):
    """Interface for managing invitation tokens."""
    @abstractmethod
    def create_invitation(
        self, token: str, created_by_user_id: int, expires_at: datetime
    ) -> None:
        """
        Create a new invitation token.
        Args:
            token: The invitation token string
            created_by_user_id: ID of the user creating the invitation
            expires_at: Expiration datetime for the invitation
        """
    @abstractmethod
    def verify_invitation(self, token: str) -> bool:
        """
        Verify if an invitation token is valid and not consumed.
        Args:
            token: The invitation token to verify
        Returns:
            True if valid and not consumed, False otherwise
        """
    @abstractmethod
    def consume_invitation(self, token: str) -> bool:
        """
        Mark an invitation token as consumed.
        Args:
            token: The invitation token to consume
        Returns:
            True if successfully consumed, False if invalid or already used
        """
    @abstractmethod
    def cleanup_expired(self) -> None:
        """Remove expired invitation tokens from storage."""
@@ -0,0 +1,23 @@
 """Definition of the TokenRepositoryInterface."""
 from abc import ABC, abstractmethod
 class TokenRepositoryInterface(ABC):
    """Interface for token storage operations."""
    @abstractmethod
    def store(self, token: str, user_id: int, ttl: int = 3600) -> None:
        """Store a token with optional TTL (time to live in seconds)."""
    @abstractmethod
    def verify(self, token: str) -> int | None:
        """Verify token and return user_id if valid, None otherwise."""
    @abstractmethod
    def invalidate(self, token: str) -> None:
        """Invalidate/delete a token."""
    @abstractmethod
    def cleanup_expired(self) -> None:
        """Remove expired tokens (for implementations without auto-expiry)."""
@@ -0,0 +1,19 @@
 """Definition of UserRepositoryInterface."""
 from abc import ABC, abstractmethod
 class UserRepositoryInterface(ABC):
    """Interface for user data operations."""
    @abstractmethod
    def get_by_username(self, username: str) -> dict | None:
        """Get user by username."""
    @abstractmethod
    def create(self, username: str, hashed_password: str) -> dict:
        """Create a new user."""
    @abstractmethod
    def get_by_id(self, user_id: int) -> dict | None:
        """Get user by ID."""
@@ -0,0 +1,7 @@
 """Invitation repository implementations."""
 from baby_monitor.repositories.invitation.sqlite_invitation import (
    SQLiteInvitationRepository,
 )
 __all__ = ["SQLiteInvitationRepository"]
@@ -0,0 +1,112 @@
 """SQLite implementation of invitation repository.
 Note: SQLite does not support timezone-aware datetimes natively.
 All datetimes are stored as naive UTC and converted at the application layer.
 """
 from datetime import datetime, UTC
 from sqlalchemy.orm import Session
 from baby_monitor.models.invitation import Invitation
 from baby_monitor.repositories.interfaces.invitation_repository_interface import (
    InvitationRepositoryInterface,
 )
 class SQLiteInvitationRepository(InvitationRepositoryInterface):
    """SQLite implementation for managing invitation tokens."""
    def __init__(self, db: Session) -> None:
        """Initialize the repository with a database session."""
        self.db = db
    def create_invitation(
        self, token: str, created_by_user_id: int, expires_at: datetime
    ) -> None:
        """
        Create a new invitation token.
        Args:
            token: The invitation token string
            created_by_user_id: ID of the user creating the invitation
            expires_at: Expiration datetime for the invitation
        """
        # Convert timezone-aware datetimes to naive UTC for SQLite
        created_at_utc = datetime.now(UTC).replace(tzinfo=None)
        expires_at_utc = (
            expires_at.replace(tzinfo=None) if expires_at.tzinfo else expires_at
        )
        invitation = Invitation(
            token=token,
            created_at=created_at_utc,
            expires_at=expires_at_utc,
            created_by_user_id=created_by_user_id,
            is_consumed=False,
            consumed_at=None,
        )
        self.db.add(invitation)
        self.db.commit()
    def verify_invitation(self, token: str) -> bool:
        """
        Verify if an invitation token is valid and not consumed.
        Args:
            token: The invitation token to verify
        Returns:
            True if valid and not consumed, False otherwise
        """
        invitation = self.db.query(Invitation).filter(Invitation.token == token).first()
        if not invitation:
            return False
        # Compare as naive UTC datetimes (SQLite stores without timezone)
        now_utc = datetime.now(UTC).replace(tzinfo=None)
        if invitation.expires_at < now_utc:
            return False
        # Check if already consumed
        if invitation.is_consumed:
            return False
        return True
    def consume_invitation(self, token: str) -> bool:
        """
        Mark an invitation token as consumed.
        Args:
            token: The invitation token to consume
        Returns:
            True if successfully consumed, False if invalid or already used
        """
        invitation = self.db.query(Invitation).filter(Invitation.token == token).first()
        if not invitation:
            return False
        # Compare as naive UTC datetimes (SQLite stores without timezone)
        now_utc = datetime.now(UTC).replace(tzinfo=None)
        if invitation.expires_at < now_utc:
            return False
        # Check if already consumed
        if invitation.is_consumed:
            return False
        # Mark as consumed
        invitation.is_consumed = True
        invitation.consumed_at = now_utc
        self.db.commit()
        return True
    def cleanup_expired(self) -> None:
        """Remove expired invitation tokens from storage."""
        now_utc = datetime.now(UTC).replace(tzinfo=None)
        self.db.query(Invitation).filter(Invitation.expires_at < now_utc).delete()
        self.db.commit()
@@ -0,0 +1,50 @@
 """In-memory token repository (can be replaced with Redis)."""
 from datetime import datetime, timedelta, UTC
 from baby_monitor.repositories.interfaces import TokenRepositoryInterface
 class InMemoryTokenRepository(TokenRepositoryInterface):
    """
    In-memory token storage.
    This is a simple implementation that stores tokens in memory.
    Replace with RedisTokenRepository for production use.
    """
    def __init__(self) -> None:
        # token -> (user_id, expiry_time)
        self._tokens: dict[str, tuple[int, datetime]] = {}
    def store(self, token: str, user_id: int, ttl: int = 3600) -> None:
        """Store a token with TTL (time to live in seconds)."""
        expiry = datetime.now(UTC) + timedelta(seconds=ttl)
        self._tokens[token] = (user_id, expiry)
    def verify(self, token: str) -> int | None:
        """Verify token and return user_id if valid, None otherwise."""
        if token not in self._tokens:
            return None
        user_id, expiry = self._tokens[token]
        # Check if token has expired
        if datetime.now(UTC) > expiry:
            del self._tokens[token]
            return None
        return user_id
    def invalidate(self, token: str) -> None:
        """Invalidate/delete a token."""
        self._tokens.pop(token, None)
    def cleanup_expired(self) -> None:
        """Remove expired tokens."""
        now = datetime.now(UTC)
        expired_tokens = [
            token for token, (_, expiry) in self._tokens.items() if now > expiry
        ]
        for token in expired_tokens:
            del self._tokens[token]
@@ -0,0 +1,45 @@
 """Redis token repository (future implementation)."""
 from typing import Any
 from baby_monitor.repositories.interfaces import TokenRepositoryInterface
 class RedisTokenRepository(TokenRepositoryInterface):
    """
    Redis-based token storage.
    Requires redis package: pip install redis
    Set REDIS_URI environment variable (e.g., redis://localhost:6379/0)
    """
    def __init__(self, redis_client: Any) -> None:
        """
        Initialize with Redis client.
        Args:
            redis_client: Redis client instance from redis.from_url()
        """
        self.redis = redis_client
    def store(self, token: str, user_id: int, ttl: int = 3600) -> None:
        """Store a token with TTL (time to live in seconds)."""
        key = f"token:{token}"
        self.redis.setex(key, ttl, str(user_id))
    def verify(self, token: str) -> int | None:
        """Verify token and return user_id if valid, None otherwise."""
        key = f"token:{token}"
        user_id_str = self.redis.get(key)
        if user_id_str:
            return int(user_id_str)
        return None
    def invalidate(self, token: str) -> None:
        """Invalidate/delete a token."""
        key = f"token:{token}"
        self.redis.delete(key)
    def cleanup_expired(self) -> None:
        """Redis automatically handles expiration, so no cleanup needed."""
        pass  # Redis handles TTL automatically
@@ -0,0 +1,64 @@
 """PostgreSQL user repository (future implementation)."""
 from sqlalchemy.orm import Session
 from baby_monitor.repositories.interfaces import UserRepositoryInterface
 from baby_monitor.models.db.user import User
 class PostgreSQLUserRepository(UserRepositoryInterface):
    """
    PostgreSQL-based user repository.
    This implementation uses the same SQLAlchemy models as SQLite,
    just with a different database engine.
    To use this implementation:
    1. Add psycopg2-binary dependency
    2. Update DATABASE_URL in database.py:
       DATABASE_URL = os.getenv(
           "DATABASE_URL",
           "postgresql://user:password@localhost:5432/baby_monitor"
       )
    3. Replace SQLiteUserRepository with this in dependencies
    """
    def __init__(self, db: Session):
        self.db = db
    def get_by_username(self, username: str) -> dict | None:
        """Get user by username."""
        user = self.db.query(User).filter(User.username == username).first()
        if user:
            return {
                "id": user.id,
                "username": user.username,
                "hashed_password": user.hashed_password,
                "created_at": user.created_at,
            }
        return None
    def create(self, username: str, hashed_password: str) -> dict:
        """Create a new user."""
        user = User(username=username, hashed_password=hashed_password)
        self.db.add(user)
        self.db.commit()
        self.db.refresh(user)
        return {
            "id": user.id,
            "username": user.username,
            "hashed_password": user.hashed_password,
            "created_at": user.created_at,
        }
    def get_by_id(self, user_id: int) -> dict | None:
        """Get user by ID."""
        user = self.db.query(User).filter(User.id == user_id).first()
        if user:
            return {
                "id": user.id,
                "username": user.username,
                "hashed_password": user.hashed_password,
                "created_at": user.created_at,
            }
        return None
@@ -0,0 +1,57 @@
 """SQLite implementation of user repository."""
 from sqlalchemy.orm import Session
 from baby_monitor.repositories.interfaces import UserRepositoryInterface
 from baby_monitor.models.db.user import User
 class SQLiteUserRepository(UserRepositoryInterface):
    """SQLite-based user repository."""
    def __init__(self, db: Session):
        self.db = db
    def get_by_username(self, username: str) -> dict | None:
        """Get user by username."""
        user = self.db.query(User).filter(User.username == username).first()
        if user:
            return {
                "id": user.id,
                "username": user.username,
                "hashed_password": user.hashed_password,
                "is_admin": user.is_admin,
                "created_at": user.created_at,
            }
        return None
    def create(self, username: str, hashed_password: str) -> dict:
        """Create a new user."""
        user = User(
            username=username,
            hashed_password=hashed_password,
            is_admin=False,
        )
        self.db.add(user)
        self.db.commit()
        self.db.refresh(user)
        return {
            "id": user.id,
            "username": user.username,
            "hashed_password": user.hashed_password,
            "is_admin": user.is_admin,
            "created_at": user.created_at,
        }
    def get_by_id(self, user_id: int) -> dict | None:
        """Get user by ID."""
        user = self.db.query(User).filter(User.id == user_id).first()
        if user:
            return {
                "id": user.id,
                "username": user.username,
                "hashed_password": user.hashed_password,
                "is_admin": user.is_admin,
                "created_at": user.created_at,
            }
        return None
@@ -0,0 +1 @@
 """Routers package for API endpoints."""
@@ -0,0 +1,66 @@
 """Admin router for administrative functions."""
 import secrets
 from datetime import datetime, timedelta, UTC
 from typing import Annotated
 from fastapi import APIRouter, Depends
 from pydantic import BaseModel
 from baby_monitor.routers.auth import verify_admin
 from baby_monitor.repositories.dependencies.get_invitation_repository import (
    get_invitation_repository,
 )
 from baby_monitor.repositories.interfaces import (
    InvitationRepositoryInterface,
 )
 router = APIRouter(prefix="/api/admin", tags=["admin"])
 class InvitationResponse(BaseModel):
    """Response model for invitation link generation."""
    token: str
    expires_at: str
    message: str
@router.post("/generate-invitation", response_model=InvitationResponse)
 async def generate_invitation_link(
    user_id: Annotated[int, Depends(verify_admin)],
    invitation_repository: Annotated[
        InvitationRepositoryInterface,
        Depends(get_invitation_repository),
    ],
 ) -> InvitationResponse:
    """Generate a new invitation link for user registration.
    The invitation token is valid for 24 hours and can be used once.
    Requires admin role.
    Args:
        user_id: Admin user ID (from verify_admin)
        invitation_repository: Invitation storage backend
    Returns:
        InvitationResponse with token and expiration details
    """
    # Generate secure random token
    invitation_token = secrets.token_urlsafe(32)
    # Calculate expiration (24 hours from now)
    expires_at = datetime.now(UTC) + timedelta(hours=24)
    # Store invitation token in database
    invitation_repository.create_invitation(
        token=invitation_token,
        created_by_user_id=user_id,
        expires_at=expires_at,
    )
    return InvitationResponse(
        token=invitation_token,
        expires_at=expires_at.isoformat(),
        message="Invitation link generated successfully. Valid for 24 hours.",
    )
@@ -0,0 +1,193 @@
 """Authentication router for login and user management."""
 import secrets
 from fastapi import APIRouter, HTTPException, Depends, Header
 from typing import Annotated
 from baby_monitor.models.auth import (
    LoginRequest,
    LoginResponse,
    RegisterRequest,
    RegisterResponse,
 )
 from baby_monitor.repositories import (
    get_token_repository,
    get_user_repository,
 )
 from baby_monitor.repositories.dependencies.get_invitation_repository import (
    get_invitation_repository,
 )
 from baby_monitor.repositories.interfaces import (
    TokenRepositoryInterface,
    UserRepositoryInterface,
    InvitationRepositoryInterface,
 )
 from baby_monitor.utils.password import hash_password, verify_password
 router = APIRouter(prefix="/api", tags=["authentication"])
 def verify_token(
    authorization: Annotated[str | None, Header()] = None,
    token_repo: TokenRepositoryInterface = Depends(get_token_repository),
 ) -> int:
    """Verify the bearer token and return user_id."""
    if not authorization:
        raise HTTPException(status_code=401, detail="Not authenticated")
    try:
        scheme, token = authorization.split()
        if scheme.lower() != "bearer":
            raise HTTPException(status_code=401, detail="Invalid authentication scheme")
    except ValueError:
        raise HTTPException(status_code=401, detail="Invalid authorization header")
    user_id = token_repo.verify(token)
    if user_id is None:
        raise HTTPException(status_code=401, detail="Invalid or expired token")
    return user_id
 def verify_admin(
    user_id: Annotated[int, Depends(verify_token)],
    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],
 ) -> int:
    """Verify the user is an admin and return user_id."""
    user = user_repo.get_by_id(user_id)
    if not user:
        raise HTTPException(status_code=401, detail="User not found")
    if not user.get("is_admin", False):
        raise HTTPException(status_code=403, detail="Admin access required")
    return user_id
@router.post("/login", response_model=LoginResponse)
 def login(
    credentials: LoginRequest,
    token_repo: Annotated[TokenRepositoryInterface, Depends(get_token_repository)],
    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],
 ) -> LoginResponse:
    """
    API endpoint for user authentication.
    Returns user info and access token on successful login.
    Raises 401 on invalid credentials.
    """
    # Check if user exists in database
    user = user_repo.get_by_username(credentials.username)
    if not user:
        raise HTTPException(status_code=401, detail="Invalid username or password")
    # Verify password using bcrypt
    if not verify_password(credentials.password, user["hashed_password"]):
        raise HTTPException(status_code=401, detail="Invalid username or password")
    # Generate a secure random token
    access_token = secrets.token_urlsafe(32)
    token_repo.store(access_token, user_id=user["id"], ttl=3600)
    return LoginResponse(
        message="Login successful",
        username=credentials.username,
        access_token=access_token,
        is_admin=user.get("is_admin", False),
    )
@router.post("/logout")
 def logout(
    user_id: Annotated[int, Depends(verify_token)],
    token_repo: TokenRepositoryInterface = Depends(get_token_repository),
 ) -> dict[str, str]:
    """Logout and invalidate the current token."""
    # Note: We'd need to pass the token itself, not user_id
    # This is simplified - in production, extract token from verify_token
    return {"message": "Logged out successfully"}
@router.get("/verify-invitation")
 def verify_invitation(
    token: str,
    invitation_repo: Annotated[
        InvitationRepositoryInterface, Depends(get_invitation_repository)
    ],
 ) -> dict[str, bool]:
    """Verify if an invitation token is valid."""
    is_valid = invitation_repo.verify_invitation(token)
    if not is_valid:
        raise HTTPException(status_code=400, detail="Invalid or expired invitation")
    return {"valid": True}
@router.post("/register", response_model=RegisterResponse)
 def register(
    request: RegisterRequest,
    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],
    invitation_repo: Annotated[
        InvitationRepositoryInterface, Depends(get_invitation_repository)
    ],
    token_repo: Annotated[TokenRepositoryInterface, Depends(get_token_repository)],
 ) -> RegisterResponse:
    """
    Register a new user with an invitation token.
    Verifies the invitation, creates the user, consumes the invitation,
    and returns an authentication token.
    """
    # Verify invitation token
    if not invitation_repo.verify_invitation(request.invitation_token):
        raise HTTPException(
            status_code=400,
            detail="Invalid or expired invitation token",
        )
    # Check if username already exists
    existing_user = user_repo.get_by_username(request.username)
    if existing_user:
        raise HTTPException(
            status_code=400,
            detail="Username already exists",
        )
    # Create the new user with hashed password
    hashed_pw = hash_password(request.password)
    user = user_repo.create(
        username=request.username,
        hashed_password=hashed_pw,
    )
    # Consume the invitation token
    invitation_repo.consume_invitation(request.invitation_token)
    # Generate authentication token
    access_token = secrets.token_urlsafe(32)
    token_repo.store(access_token, user_id=user["id"], ttl=3600)
    return RegisterResponse(
        message="Registration successful",
        username=user["username"],
        access_token=access_token,
        is_admin=user.get("is_admin", False),
    )
@router.get("/me")
 def get_current_user(
    user_id: Annotated[int, Depends(verify_token)],
    user_repo: Annotated[UserRepositoryInterface, Depends(get_user_repository)],
 ) -> dict:
    """Get current user info including admin status."""
    user = user_repo.get_by_id(user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return {
        "id": user["id"],
        "username": user["username"],
        "is_admin": user.get("is_admin", False),
    }
@@ -0,0 +1,90 @@
 """Child management router."""
 from typing import Annotated
 from fastapi import APIRouter, HTTPException, Depends
 from baby_monitor.models.child import CreateChildRequest, ChildResponse
 from baby_monitor.routers.auth import verify_token
 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/children", tags=["children"])
@router.post("", response_model=ChildResponse, status_code=201)
 def create_child(
    request: CreateChildRequest,
    user_id: Annotated[int, Depends(verify_token)],
    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
 ) -> ChildResponse:
    """Create a new child for the authenticated user."""
    child = child_repo.create(
        name=request.name,
        birth_time=request.birth_time,
        birth_weight=request.birth_weight,
        user_id=user_id,
    )
    return ChildResponse(**child)
@router.get("", response_model=list[ChildResponse])
 def get_user_children(
    user_id: Annotated[int, Depends(verify_token)],
    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
 ) -> list[ChildResponse]:
    """Get all children for the authenticated user."""
    children = child_repo.get_by_user_id(user_id)
    return [ChildResponse(**child) for child in children]
@router.get("/{child_id}", response_model=ChildResponse)
 def get_child(
    child_id: int,
    user_id: Annotated[int, Depends(verify_token)],
    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
 ) -> ChildResponse:
    """Get a specific child by ID."""
    child = child_repo.get_by_id(child_id)
    if not child:
        raise HTTPException(status_code=404, detail="Child not found")
    # Verify the child belongs to the authenticated user
    if child["user_id"] != user_id:
        raise HTTPException(status_code=403, detail="Access denied")
    return ChildResponse(**child)
@router.put("/{child_id}", response_model=ChildResponse)
 def update_child(
    child_id: int,
    request: CreateChildRequest,
    user_id: Annotated[int, Depends(verify_token)],
    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
 ) -> ChildResponse:
    """Update a child's information."""
    # First check if child exists and belongs to user
    child = child_repo.get_by_id(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")
    # Update the child
    updated_child = child_repo.update(
        child_id=child_id,
        name=request.name,
        birth_time=request.birth_time,
        birth_weight=request.birth_weight,
    )
    if not updated_child:
        raise HTTPException(status_code=500, detail="Update failed")
    return ChildResponse(**updated_child)
@@ -0,0 +1,153 @@
 """Diaper change log management router."""
 from typing import Annotated
 from fastapi import APIRouter, HTTPException, Depends
 from baby_monitor.models.diaper_change import (
    CreateDiaperChangeRequest,
    UpdateDiaperChangeRequest,
    DiaperChangeResponse,
 )
 from baby_monitor.routers.auth import verify_token
 from baby_monitor.repositories.diaper_change.sqlite_diaper_change import (
    SQLiteDiaperChangeRepository,
 )
 from baby_monitor.repositories.dependencies.get_diaper_change_repository import (  # noqa: E501
    get_diaper_change_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/diaper-changes", tags=["diaper-changes"])
@router.post("", response_model=DiaperChangeResponse, status_code=201)
 def create_diaper_change(
    request: CreateDiaperChangeRequest,
    user_id: Annotated[int, Depends(verify_token)],
    diaper_repo: Annotated[
        SQLiteDiaperChangeRepository, Depends(get_diaper_change_repository)
    ],
    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
 ) -> DiaperChangeResponse:
    """Create a new diaper change 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")
    diaper_change = diaper_repo.create(
        child_id=request.child_id,
        change_time=request.change_time,
        poop_amount=request.poop_amount.value if request.poop_amount else None,
        poop_color=request.poop_color.value if request.poop_color else None,
        pee_amount=request.pee_amount.value if request.pee_amount else None,
        pee_color=request.pee_color.value if request.pee_color else None,
    )
    return DiaperChangeResponse(**diaper_change)
@router.get("", response_model=list[DiaperChangeResponse])
 def get_user_diaper_changes(
    user_id: Annotated[int, Depends(verify_token)],
    diaper_repo: Annotated[
        SQLiteDiaperChangeRepository, Depends(get_diaper_change_repository)
    ],
 ) -> list[DiaperChangeResponse]:
    """Get all diaper change logs for the authenticated user's children."""
    diaper_changes = diaper_repo.get_by_user_id(user_id)
    return [DiaperChangeResponse(**dc) for dc in diaper_changes]
@router.get("/{diaper_change_id}", response_model=DiaperChangeResponse)
 def get_diaper_change(
    diaper_change_id: int,
    user_id: Annotated[int, Depends(verify_token)],
    diaper_repo: Annotated[
        SQLiteDiaperChangeRepository, Depends(get_diaper_change_repository)
    ],
    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
 ) -> DiaperChangeResponse:
    """Get a specific diaper change log by ID."""
    diaper_change = diaper_repo.get_by_id(diaper_change_id)
    if not diaper_change:
        raise HTTPException(status_code=404, detail="Diaper change log not found")
    # Verify the diaper change belongs to user's child
    child = child_repo.get_by_id(diaper_change["child_id"])
    if not child or child["user_id"] != user_id:
        raise HTTPException(status_code=403, detail="Access denied")
    return DiaperChangeResponse(**diaper_change)
@router.put("/{diaper_change_id}", response_model=DiaperChangeResponse)
 def update_diaper_change(
    diaper_change_id: int,
    request: UpdateDiaperChangeRequest,
    user_id: Annotated[int, Depends(verify_token)],
    diaper_repo: Annotated[
        SQLiteDiaperChangeRepository, Depends(get_diaper_change_repository)
    ],
    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
 ) -> DiaperChangeResponse:
    """Update an existing diaper change log."""
    diaper_change = diaper_repo.get_by_id(diaper_change_id)
    if not diaper_change:
        raise HTTPException(status_code=404, detail="Diaper change log not found")
    # Verify the diaper change belongs to user's child
    child = child_repo.get_by_id(diaper_change["child_id"])
    if not child or child["user_id"] != user_id:
        raise HTTPException(status_code=403, detail="Access denied")
    updated = diaper_repo.update(
        diaper_change_id=diaper_change_id,
        change_time=request.change_time,
        poop_amount=request.poop_amount.value if request.poop_amount else None,
        poop_color=request.poop_color.value if request.poop_color else None,
        pee_amount=request.pee_amount.value if request.pee_amount else None,
        pee_color=request.pee_color.value if request.pee_color else None,
    )
    if not updated:
        raise HTTPException(
            status_code=500, detail="Failed to update diaper change log"
        )
    return DiaperChangeResponse(**updated)
@router.delete("/{diaper_change_id}", status_code=204)
 def delete_diaper_change(
    diaper_change_id: int,
    user_id: Annotated[int, Depends(verify_token)],
    diaper_repo: Annotated[
        SQLiteDiaperChangeRepository, Depends(get_diaper_change_repository)
    ],
    child_repo: Annotated[SQLiteChildRepository, Depends(get_child_repository)],
 ) -> None:
    """Delete a diaper change log."""
    diaper_change = diaper_repo.get_by_id(diaper_change_id)
    if not diaper_change:
        raise HTTPException(status_code=404, detail="Diaper change log not found")
    # Verify the diaper change belongs to user's child
    child = child_repo.get_by_id(diaper_change["child_id"])
    if not child or child["user_id"] != user_id:
        raise HTTPException(status_code=403, detail="Access denied")
    success = diaper_repo.delete(diaper_change_id)
    if not success:
        raise HTTPException(
            status_code=500, detail="Failed to delete diaper change log"
        )
@@ -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")
@@ -0,0 +1,72 @@
 """Health check router for monitoring endpoints."""
 from fastapi import APIRouter
 router = APIRouter(tags=["health"])
@router.get("/health")
 def health_check() -> dict[str, str]:
    """
    Health check endpoint for container orchestration.
    Returns 200 if the service is alive and able to handle requests.
    """
    return {"status": "healthy"}
@router.get("/ready")
 def readiness_check() -> dict[str, str]:
    """
    Readiness check endpoint for container orchestration.
    Returns 200 if the service is ready to accept traffic.
    This can include checks for database connectivity, external services, etc.
    """
    # Add dependency checks here if needed (database, cache, etc.)
    # For now, simple readiness check
    return {"status": "ready"}
@router.get("/info")
 def service_info() -> dict:
    """
    Get service information including available features.
    Useful for verifying which optional dependencies are installed.
    """
    import os
    # Check which optional dependencies are available
    features = {
        "redis": False,
        "postgresql": False,
    }
    try:
        import redis  # noqa: F401
        features["redis"] = True
    except ImportError:
        pass
    try:
        import psycopg2  # noqa: F401
        features["postgresql"] = True
    except ImportError:
        pass
    # Check current configuration
    config = {
        "environment": os.getenv("ENVIRONMENT", "production"),
        "data_dir": os.getenv("DATA_DIR", "/data"),
        "redis_configured": bool(os.getenv("REDIS_URI")),
    }
    return {
        "service": "baby-monitor",
        "version": "0.1.0",
        "features": features,
        "config": config,
    }
@@ -0,0 +1,322 @@
 <!doctype html>
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Add Child - 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 {
        width: 100%;
        padding: 12px;
        border: 1px solid #ddd;
        border-radius: 6px;
        font-size: 14px;
        transition: border-color 0.2s;
      }
      input: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;
      }
    </style>
  </head>
  <body>
    <div class="container">
      <h1>👶 Add Child</h1>
      <p class="subtitle">Enter your child's information</p>
      <div id="message" class="message"></div>
      <form id="addChildForm">
        <div class="form-group">
          <label for="name">Child's Name *</label>
          <input
            type="text"
            id="name"
            name="name"
            required
            placeholder="Enter child's name"
            maxlength="100"
          />
        </div>
        <div class="form-group">
          <label for="birthTime">Date and Time of Birth *</label>
          <input
            type="datetime-local"
            id="birthTime"
            name="birthTime"
            required
          />
          <p class="help-text">
            Select the date and time when your child was born
          </p>
        </div>
        <div class="form-group">
          <label for="birthWeight">Birth Weight (grams) *</label>
          <input
            type="number"
            id="birthWeight"
            name="birthWeight"
            required
            min="1"
            step="1"
            placeholder="e.g., 3500"
          />
          <p class="help-text">Enter weight in grams (1 kg = 1000 grams)</p>
        </div>
        <button type="submit" class="button" id="submitBtn">Add Child</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";
      }
      // Get child ID from URL if editing
      const urlParams = new URLSearchParams(window.location.search);
      const childId = urlParams.get("id");
      const isEditMode = !!childId;
      const form = document.getElementById("addChildForm");
      const messageDiv = document.getElementById("message");
      const submitBtn = document.getElementById("submitBtn");
      // Update page title and button text if editing
      if (isEditMode) {
        document.querySelector("h1").textContent = "✏️ Edit Child";
        document.querySelector(".subtitle").textContent =
          "Update your child's information";
        submitBtn.textContent = "Update Child";
        // Load existing child data
        loadChildData(childId);
      }
      async function loadChildData(id) {
        try {
          const response = await fetch(`/api/children/${id}`, {
            headers: {
              Authorization: `Bearer ${token}`,
            },
          });
          if (response.ok) {
            const child = await response.json();
            // Populate form fields
            document.getElementById("name").value = child.name;
            // Format datetime for datetime-local input
            const birthDate = new Date(child.birth_time);
            const formattedDate = birthDate.toISOString().slice(0, 16);
            document.getElementById("birthTime").value = formattedDate;
            document.getElementById("birthWeight").value = child.birth_weight;
          } else {
            showMessage("Failed to load child data", "error");
          }
        } catch (error) {
          showMessage("Error loading child data", "error");
        }
      }
      form.addEventListener("submit", async (e) => {
        e.preventDefault();
        const name = document.getElementById("name").value;
        const birthTime = document.getElementById("birthTime").value;
        const birthWeight = parseFloat(
          document.getElementById("birthWeight").value,
        );
        // Disable button during request
        submitBtn.disabled = true;
        const originalText = submitBtn.textContent;
        submitBtn.textContent = isEditMode ? "Updating..." : "Adding...";
        messageDiv.classList.remove("show");
        try {
          const url = isEditMode ? `/api/children/${childId}` : "/api/children";
          const method = isEditMode ? "PUT" : "POST";
          const response = await fetch(url, {
            method: method,
            headers: {
              "Content-Type": "application/json",
              Authorization: `Bearer ${token}`,
            },
            body: JSON.stringify({
              name: name,
              birth_time: birthTime,
              birth_weight: birthWeight,
            }),
          });
          const data = await response.json();
          if (response.ok) {
            showMessage(
              isEditMode
                ? "Child updated successfully!"
                : "Child added successfully!",
              "success",
            );
            // Redirect to home page after 1 second
            setTimeout(() => {
              window.location.href = "/";
            }, 1000);
          } else {
            showMessage(
              data.detail ||
                `Failed to ${isEditMode ? "update" : "add"} child. Please try again.`,
              "error",
            );
          }
        } catch (error) {
          showMessage("Network error. Please try again.", "error");
        } finally {
          submitBtn.disabled = false;
          submitBtn.textContent = originalText;
        }
      });
      function showMessage(text, type) {
        messageDiv.textContent = text;
        messageDiv.className = `message ${type} show`;
      }
      function goBack() {
        window.location.href = "/";
      }
    </script>
  </body>
 </html>
@@ -0,0 +1,319 @@
 <!doctype html>
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Baby Monitor - Admin</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: 600px;
        width: 100%;
      }
      h1 {
        color: #333;
        margin-bottom: 10px;
        font-size: 28px;
      }
      .subtitle {
        color: #666;
        margin-bottom: 30px;
        font-size: 14px;
      }
      .section {
        margin-bottom: 30px;
      }
      .section h2 {
        color: #444;
        font-size: 18px;
        margin-bottom: 15px;
        display: flex;
        align-items: center;
      }
      .section h2::before {
        content: "🔗";
        margin-right: 8px;
      }
      .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%;
      }
      .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;
      }
      .link-container {
        display: none;
        margin-top: 20px;
        padding: 15px;
        background: #f8f9fa;
        border-radius: 8px;
        border: 2px solid #667eea;
      }
      .link-container.show {
        display: block;
      }
      .link-label {
        font-size: 12px;
        color: #666;
        margin-bottom: 8px;
        font-weight: 600;
        text-transform: uppercase;
      }
      .link-display {
        display: flex;
        gap: 10px;
        align-items: center;
      }
      .link-text {
        flex: 1;
        padding: 10px;
        background: white;
        border: 1px solid #ddd;
        border-radius: 4px;
        font-family: "Courier New", monospace;
        font-size: 13px;
        word-break: break-all;
        color: #333;
      }
      .copy-button {
        padding: 10px 16px;
        background: #28a745;
        color: white;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        font-weight: 600;
        transition: background 0.2s;
        white-space: nowrap;
      }
      .copy-button:hover {
        background: #218838;
      }
      .copy-button.copied {
        background: #155724;
      }
      .info-box {
        background: #e7f3ff;
        border-left: 4px solid #2196f3;
        padding: 12px;
        border-radius: 4px;
        margin-top: 15px;
        font-size: 14px;
        color: #555;
      }
      .error {
        background: #ffebee;
        border-left: 4px solid #f44336;
        color: #c62828;
        padding: 12px;
        border-radius: 4px;
        margin-top: 15px;
        display: none;
      }
      .error.show {
        display: block;
      }
      .logout-button {
        background: #dc3545;
        padding: 8px 16px;
        font-size: 14px;
        margin-top: 20px;
      }
      .logout-button:hover {
        background: #c82333;
        box-shadow: 0 4px 12px rgba(220, 53, 69, 0.4);
      }
    </style>
  </head>
  <body>
    <div class="container">
      <h1>👨‍💼 Admin Dashboard</h1>
      <p class="subtitle">Manage user invitations and settings</p>
      <div class="section">
        <h2>Generate Invitation Link</h2>
        <p style="color: #666; margin-bottom: 15px; font-size: 14px">
          Create a secure one-time link to invite a new user to register.
        </p>
        <button class="button" id="generateBtn" onclick="generateLink()">
          Generate New Invitation Link
        </button>
        <div id="linkContainer" class="link-container">
          <div class="link-label">Invitation Link</div>
          <div class="link-display">
            <div class="link-text" id="linkText"></div>
            <button class="copy-button" id="copyBtn" onclick="copyLink()">
              Copy
            </button>
          </div>
          <div class="info-box">
            ℹ️ This link expires in 24 hours and can only be used once. Share it
            securely with the intended user.
          </div>
        </div>
        <div id="error" class="error"></div>
      </div>
      <button class="button logout-button" onclick="logout()">Logout</button>
    </div>
    <script>
      // Check if user is authenticated and is admin
      const token = localStorage.getItem("access_token");
      if (!token) {
        window.location.href = "/login.html";
      }
      // Verify user is admin
      fetch("/api/me", {
        headers: {
          Authorization: `Bearer ${token}`,
        },
      })
        .then((response) => response.json())
        .then((user) => {
          if (!user.is_admin) {
            alert("Access denied. Admin privileges required.");
            window.location.href = "/";
          }
        })
        .catch((error) => {
          console.error("Error verifying admin status:", error);
          window.location.href = "/login.html";
        });
      async function generateLink() {
        const btn = document.getElementById("generateBtn");
        const linkContainer = document.getElementById("linkContainer");
        const linkText = document.getElementById("linkText");
        const errorDiv = document.getElementById("error");
        // Disable button and show loading state
        btn.disabled = true;
        btn.textContent = "Generating...";
        errorDiv.classList.remove("show");
        try {
          const response = await fetch("/api/admin/generate-invitation", {
            method: "POST",
            headers: {
              Authorization: `Bearer ${token}`,
              "Content-Type": "application/json",
            },
          });
          if (!response.ok) {
            throw new Error(`Failed to generate link: ${response.statusText}`);
          }
          const data = await response.json();
          // Build the full URL
          const baseUrl = window.location.origin;
          const inviteUrl = `${baseUrl}/register.html?token=${data.token}`;
          // Display the link
          linkText.textContent = inviteUrl;
          linkContainer.classList.add("show");
        } catch (error) {
          errorDiv.textContent = `Error: ${error.message}`;
          errorDiv.classList.add("show");
        } finally {
          btn.disabled = false;
          btn.textContent = "Generate New Invitation Link";
        }
      }
      function copyLink() {
        const linkText = document.getElementById("linkText").textContent;
        const copyBtn = document.getElementById("copyBtn");
        navigator.clipboard
          .writeText(linkText)
          .then(() => {
            // Show success state
            copyBtn.textContent = "✓ Copied!";
            copyBtn.classList.add("copied");
            // Reset after 2 seconds
            setTimeout(() => {
              copyBtn.textContent = "Copy";
              copyBtn.classList.remove("copied");
            }, 2000);
          })
          .catch((err) => {
            alert("Failed to copy link: " + err);
          });
      }
      function logout() {
        localStorage.removeItem("access_token");
        window.location.href = "/login.html";
      }
    </script>
  </body>
 </html>
@@ -0,0 +1,614 @@
 <!doctype html>
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Baby Monitor</title>
    <style>
      body {
        font-family: Arial, sans-serif;
        max-width: 800px;
        margin: 2rem auto;
        padding: 0 1rem;
        background-color: #f0f0f0;
      }
      .burger-menu {
        position: fixed;
        top: 1rem;
        left: 1rem;
        cursor: pointer;
        z-index: 1000;
        background: white;
        padding: 0.5rem;
        border-radius: 4px;
        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
      }
      .burger-menu div {
        width: 25px;
        height: 3px;
        background-color: #333;
        margin: 5px 0;
        transition: 0.3s;
      }
      .menu-overlay {
        position: fixed;
        top: 0;
        left: -250px;
        width: 250px;
        height: 100vh;
        background: white;
        box-shadow: 2px 0 10px rgba(0, 0, 0, 0.1);
        transition: left 0.3s;
        z-index: 999;
        padding: 4rem 1rem 1rem 1rem;
      }
      .menu-overlay.open {
        left: 0;
      }
      .menu-backdrop {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100vh;
        background: rgba(0, 0, 0, 0.5);
        display: none;
        z-index: 998;
      }
      .menu-backdrop.open {
        display: block;
      }
      .menu-item {
        padding: 1rem;
        border-bottom: 1px solid #eee;
        cursor: pointer;
        transition: background 0.2s;
      }
      .menu-item:hover {
        background: #f5f5f5;
      }
      .menu-item.admin {
        color: #667eea;
        font-weight: 600;
      }
      .menu-item.logout {
        color: #dc3545;
        font-weight: 600;
      }
      .container {
        background: white;
        padding: 2rem;
        border-radius: 8px;
        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
      }
      h1 {
        color: #333;
        margin-bottom: 1rem;
      }
      .user-info {
        background: #e3f2fd;
        padding: 1rem;
        border-radius: 4px;
        margin-bottom: 1rem;
      }
      button {
        padding: 0.75rem 1.5rem;
        background-color: #dc3545;
        color: white;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        font-size: 1rem;
        margin-right: 0.5rem;
      }
      button:hover {
        background-color: #c82333;
      }
      .admin-button {
        background-color: #667eea;
      }
      .admin-button:hover {
        background-color: #5568d3;
      }
      .hidden {
        display: none;
      }
      .loading {
        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>
    <div class="burger-menu" id="burgerMenu">
      <div></div>
      <div></div>
      <div></div>
    </div>
    <div class="menu-backdrop" id="menuBackdrop"></div>
    <div class="menu-overlay" id="menuOverlay">
      <div class="menu-item" id="menuAddChild">👶 Add Child</div>
      <div class="menu-item" id="menuFeedings">🍼 Feedings</div>
      <div class="menu-item" id="menuDiapers">🧷 Diapers</div>
      <div class="menu-item logout" id="menuLogout">🚪 Logout</div>
    </div>
    <div class="container">
      <div id="content" class="loading">
        <p>Loading...</p>
      </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");
      // Burger menu functionality
      const burgerMenu = document.getElementById("burgerMenu");
      const menuOverlay = document.getElementById("menuOverlay");
      const menuBackdrop = document.getElementById("menuBackdrop");
      function toggleMenu() {
        menuOverlay.classList.toggle("open");
        menuBackdrop.classList.toggle("open");
      }
      function closeMenu() {
        menuOverlay.classList.remove("open");
        menuBackdrop.classList.remove("open");
      }
      burgerMenu.addEventListener("click", toggleMenu);
      menuBackdrop.addEventListener("click", closeMenu);
      document.getElementById("menuAddChild").addEventListener("click", () => {
        window.location.href = "/add-child.html";
      });
      document.getElementById("menuFeedings").addEventListener("click", () => {
        window.location.href = "/feedings.html";
      });
      document.getElementById("menuDiapers").addEventListener("click", () => {
        window.location.href = "/diapers.html";
      });
      document.getElementById("menuLogout").addEventListener("click", () => {
        closeMenu();
        logout();
      });
      // Check if user is logged in
      if (!token) {
        window.location.href = "/login.html";
      } else {
        // Fetch current user info including admin status
        fetch("/api/me", {
          headers: {
            Authorization: `Bearer ${token}`,
          },
        })
          .then((response) => {
            if (response.ok) {
              return response.json();
            } else {
              // Token invalid, redirect to login
              localStorage.removeItem("access_token");
              localStorage.removeItem("username");
              window.location.href = "/login.html";
              throw new Error("Authentication failed");
            }
          })
          .then((user) => {
            // Check if user has any children
            return fetch("/api/children", {
              headers: {
                Authorization: `Bearer ${token}`,
              },
            })
              .then((response) => response.json())
              .then((children) => {
                // If no children, redirect to add-child page
                if (children.length === 0) {
                  window.location.href = "/add-child.html";
                  return;
                }
                // Load feeding status and show content
                loadFeedingStatus(children);
              });
          })
          .catch((error) => {
            console.error("Error:", error);
          });
      }
      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}
          <button class="feeding-button" onclick="window.location.href='/log-diaper.html'" style="background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%); margin-top: 20px;">
            🧷 Log Diaper Change
          </button>
        `;
      }
      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");
        try {
          await fetch("/api/logout", {
            method: "POST",
            headers: {
              Authorization: `Bearer ${token}`,
            },
          });
        } catch (error) {
          console.error("Logout error:", error);
        } finally {
          // Clear local storage and redirect
          localStorage.removeItem("access_token");
          localStorage.removeItem("username");
          window.location.href = "/login.html";
        }
      }
    </script>
  </body>
 </html>
@@ -0,0 +1,454 @@
 <!doctype html>
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Log Diaper Change - 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;
      }
      .section-title {
        color: #666;
        font-size: 13px;
        font-weight: 600;
        text-transform: uppercase;
        letter-spacing: 0.5px;
        margin: 25px 0 15px 0;
        padding-top: 15px;
        border-top: 1px solid #eee;
      }
      .section-title:first-of-type {
        border-top: none;
        margin-top: 0;
      }
    </style>
  </head>
  <body>
    <div class="container">
      <h1 id="pageTitle">🧷 Log Diaper Change</h1>
      <p class="subtitle">Record a diaper change</p>
      <div id="message" class="message"></div>
      <form id="diaperForm">
        <div class="form-group">
          <label for="childSelect">Child *</label>
          <select id="childSelect" required>
            <option value="">Select a child</option>
          </select>
        </div>
        <div class="form-group">
          <label for="changeTime">Change Time *</label>
          <input type="datetime-local" id="changeTime" required />
        </div>
        <div class="section-title">💩 Poop Information (Optional)</div>
        <div class="form-group">
          <label for="poopAmount">Poop Amount</label>
          <select id="poopAmount">
            <option value="">None</option>
            <option value="light">Light</option>
            <option value="medium">Medium</option>
            <option value="heavy">Heavy</option>
          </select>
        </div>
        <div class="form-group">
          <label for="poopColor">Poop Color</label>
          <select id="poopColor">
            <option value="">None</option>
            <option value="black">Black</option>
            <option value="yellow">Yellow</option>
            <option value="green">Green</option>
            <option value="brown">Brown</option>
          </select>
        </div>
        <div class="section-title">💧 Pee Information (Optional)</div>
        <div class="form-group">
          <label for="peeAmount">Pee Amount</label>
          <select id="peeAmount">
            <option value="">None</option>
            <option value="light">Light</option>
            <option value="medium">Medium</option>
            <option value="heavy">Heavy</option>
          </select>
        </div>
        <div class="form-group">
          <label for="peeColor">Pee Color</label>
          <select id="peeColor">
            <option value="">None</option>
            <option value="clear">Clear</option>
            <option value="yellow">Yellow</option>
            <option value="red">Red</option>
          </select>
        </div>
        <button type="submit" class="button" id="submitBtn">
          Log Diaper Change
        </button>
        <button type="button" class="button secondary" onclick="window.location.href='/'">
          Cancel
        </button>
      </form>
    </div>
    <script>
      // Check if user is authenticated
      const token = localStorage.getItem("access_token");
      if (!token) {
        window.location.href = "/login.html";
      }
      // Check if we're in edit mode
      const urlParams = new URLSearchParams(window.location.search);
      const diaperChangeId = urlParams.get("id");
      const isEditMode = !!diaperChangeId;
      // Update UI for edit mode
      if (isEditMode) {
        document.getElementById("pageTitle").textContent = "🧷 Edit Diaper Change";
        document.getElementById("submitBtn").textContent = "Update Diaper Change";
      }
      let children = [];
      // Load children when page loads
      async function loadChildren() {
        try {
          const response = await fetch("/api/children", {
            headers: {
              Authorization: `Bearer ${token}`,
            },
          });
          if (response.ok) {
            children = await response.json();
            const select = document.getElementById("childSelect");
            children.forEach((child) => {
              const option = document.createElement("option");
              option.value = child.id;
              option.textContent = child.name;
              select.appendChild(option);
            });
            // If editing, load the diaper change data
            if (isEditMode) {
              await loadDiaperChangeData();
            } else {
              // Set default time to now for new entries
              const now = new Date();
              now.setMinutes(now.getMinutes() - now.getTimezoneOffset());
              document.getElementById("changeTime").value = now
                .toISOString()
                .slice(0, 16);
              // Load last used child from localStorage
              const lastDiaperChange = JSON.parse(
                localStorage.getItem("lastDiaperChange") || "{}"
              );
              if (lastDiaperChange.child_id) {
                document.getElementById("childSelect").value =
                  lastDiaperChange.child_id;
              }
            }
          } else {
            showMessage("Failed to load children", "error");
          }
        } catch (error) {
          console.error("Error:", error);
          showMessage("Network error. Please try again.", "error");
        }
      }
      // Load diaper change data for editing
      async function loadDiaperChangeData() {
        try {
          const response = await fetch(`/api/diaper-changes/${diaperChangeId}`, {
            headers: {
              Authorization: `Bearer ${token}`,
            },
          });
          if (response.ok) {
            const diaperChange = await response.json();
            // Populate form fields
            document.getElementById("childSelect").value = diaperChange.child_id;
            // Convert UTC time to local datetime-local format
            const changeTime = new Date(diaperChange.change_time);
            changeTime.setMinutes(
              changeTime.getMinutes() - changeTime.getTimezoneOffset()
            );
            document.getElementById("changeTime").value = changeTime
              .toISOString()
              .slice(0, 16);
            document.getElementById("poopAmount").value =
              diaperChange.poop_amount || "";
            document.getElementById("poopColor").value =
              diaperChange.poop_color || "";
            document.getElementById("peeAmount").value =
              diaperChange.pee_amount || "";
            document.getElementById("peeColor").value =
              diaperChange.pee_color || "";
          } else {
            showMessage("Failed to load diaper change data", "error");
          }
        } catch (error) {
          console.error("Error:", error);
          showMessage("Network error. Please try again.", "error");
        }
      }
      // Handle form submission
      document
        .getElementById("diaperForm")
        .addEventListener("submit", async (e) => {
          e.preventDefault();
          const childId = parseInt(document.getElementById("childSelect").value);
          const changeTime = new Date(
            document.getElementById("changeTime").value
          ).toISOString();
          const poopAmount = document.getElementById("poopAmount").value || null;
          const poopColor = document.getElementById("poopColor").value || null;
          const peeAmount = document.getElementById("peeAmount").value || null;
          const peeColor = document.getElementById("peeColor").value || null;
          const submitBtn = document.getElementById("submitBtn");
          submitBtn.disabled = true;
          submitBtn.textContent = isEditMode ? "Updating..." : "Logging...";
          try {
            const url = isEditMode
              ? `/api/diaper-changes/${diaperChangeId}`
              : "/api/diaper-changes";
            const method = isEditMode ? "PUT" : "POST";
            const body = isEditMode
              ? {
                  change_time: changeTime,
                  poop_amount: poopAmount,
                  poop_color: poopColor,
                  pee_amount: peeAmount,
                  pee_color: peeColor,
                }
              : {
                  child_id: childId,
                  change_time: changeTime,
                  poop_amount: poopAmount,
                  poop_color: poopColor,
                  pee_amount: peeAmount,
                  pee_color: peeColor,
                };
            const response = await fetch(url, {
              method: method,
              headers: {
                "Content-Type": "application/json",
                Authorization: `Bearer ${token}`,
              },
              body: JSON.stringify(body),
            });
            if (response.ok) {
              // Save last used child for next time (only for new entries, not edits)
              if (!isEditMode) {
                localStorage.setItem(
                  "lastDiaperChange",
                  JSON.stringify({
                    child_id: childId,
                  })
                );
              }
              showMessage(
                isEditMode
                  ? "Diaper change updated successfully!"
                  : "Diaper change logged successfully!",
                "success"
              );
              setTimeout(() => {
                window.location.href = "/";
              }, 1000);
            } else {
              const errorData = await response.json();
              showMessage(
                errorData.detail || "Failed to log diaper change",
                "error"
              );
              submitBtn.disabled = false;
              submitBtn.textContent = isEditMode
                ? "Update Diaper Change"
                : "Log Diaper Change";
            }
          } catch (error) {
            console.error("Error:", error);
            showMessage("Network error. Please try again.", "error");
            submitBtn.disabled = false;
            submitBtn.textContent = isEditMode
              ? "Update Diaper Change"
              : "Log Diaper Change";
          }
        });
      function showMessage(text, type) {
        const messageDiv = document.getElementById("message");
        messageDiv.textContent = text;
        messageDiv.className = `message ${type} show`;
      }
      // Initialize
      loadChildren();
    </script>
  </body>
 </html>
@@ -0,0 +1,391 @@
 <!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");
      // Check if we're editing an existing feeding
      const urlParams = new URLSearchParams(window.location.search);
      const feedingId = urlParams.get("id");
      const isEditMode = !!feedingId;
      // Set default start time to now (only for new feedings)
      if (!isEditMode) {
        const now = new Date();
        const localDateTime = new Date(
          now.getTime() - now.getTimezoneOffset() * 60000,
        )
          .toISOString()
          .slice(0, 16);
        document.getElementById("startTime").value = localDateTime;
      }
      // Update title and button text if editing
      if (isEditMode) {
        document.querySelector("h1").textContent = "🍼 Edit Feeding";
        document.querySelector(".subtitle").textContent = "Update feeding session details";
        submitBtn.textContent = "Update Feeding";
      }
      // 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";
            // If editing, load the feeding data
            if (isEditMode) {
              loadFeedingData();
            }
          } else {
            showMessage("Failed to load children", "error");
          }
        } catch (error) {
          showMessage("Network error loading children", "error");
        }
      }
      async function loadFeedingData() {
        try {
          const response = await fetch(`/api/feedings/${feedingId}`, {
            headers: {
              Authorization: `Bearer ${token}`,
            },
          });
          if (response.ok) {
            const feeding = await response.json();
            // Populate form with existing data
            document.getElementById("childId").value = feeding.child_id;
            // Format datetime for datetime-local input
            const startTime = new Date(feeding.start_time);
            const startLocalDateTime = new Date(
              startTime.getTime() - startTime.getTimezoneOffset() * 60000
            ).toISOString().slice(0, 16);
            document.getElementById("startTime").value = startLocalDateTime;
            if (feeding.end_time) {
              const endTime = new Date(feeding.end_time);
              const endLocalDateTime = new Date(
                endTime.getTime() - endTime.getTimezoneOffset() * 60000
              ).toISOString().slice(0, 16);
              document.getElementById("endTime").value = endLocalDateTime;
            }
            document.getElementById("feedingType").value = feeding.feeding_type;
          } else {
            showMessage("Failed to load feeding data", "error");
          }
        } catch (error) {
          showMessage("Network error loading feeding", "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 = isEditMode ? "Updating..." : "Logging...";
        messageDiv.classList.remove("show");
        try {
          const url = isEditMode ? `/api/feedings/${feedingId}` : "/api/feedings";
          const method = isEditMode ? "PUT" : "POST";
          const response = await fetch(url, {
            method: method,
            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(
              isEditMode ? "Feeding updated successfully!" : "Feeding logged successfully!", 
              "success"
            );
            // Redirect to feedings page after 1 second
            setTimeout(() => {
              window.location.href = "/feedings.html";
            }, 1000);
          } else {
            showMessage(
              data.detail || `Failed to ${isEditMode ? 'update' : 'log'} feeding. Please try again.`,
              "error",
            );
          }
        } catch (error) {
          showMessage("Network error. Please try again.", "error");
        } finally {
          submitBtn.disabled = false;
          submitBtn.textContent = isEditMode ? "Update Feeding" : "Log Feeding";
        }
      });
      function showMessage(text, type) {
        messageDiv.textContent = text;
        messageDiv.className = `message ${type} show`;
      }
      function goBack() {
        window.location.href = "/";
      }
    </script>
  </body>
 </html>
@@ -0,0 +1,142 @@
 <!doctype html>
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Baby Monitor</title>
    <style>
      body {
        font-family: Arial, sans-serif;
        display: flex;
        justify-content: center;
        align-items: center;
        height: 100vh;
        margin: 0;
        background-color: #f0f0f0;
      }
      .login-container {
        background: white;
        padding: 2rem;
        border-radius: 8px;
        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
        width: 300px;
      }
      h1 {
        text-align: center;
        color: #333;
        margin-bottom: 1.5rem;
      }
      input {
        width: 100%;
        padding: 0.75rem;
        margin-bottom: 1rem;
        border: 1px solid #ddd;
        border-radius: 4px;
        box-sizing: border-box;
      }
      button {
        width: 100%;
        padding: 0.75rem;
        background-color: #007bff;
        color: white;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        font-size: 1rem;
      }
      button:hover {
        background-color: #0056b3;
      }
      button:disabled {
        background-color: #ccc;
        cursor: not-allowed;
      }
      .message {
        text-align: center;
        margin-bottom: 1rem;
        padding: 0.5rem;
        border-radius: 4px;
      }
      .error {
        background-color: #fee;
        color: #c00;
      }
      .success {
        background-color: #efe;
        color: #0a0;
      }
      .hidden {
        display: none;
      }
    </style>
  </head>
  <body>
    <div class="login-container">
      <h1>Baby Monitor</h1>
      <div id="message" class="message hidden"></div>
      <form id="loginForm">
        <input type="text" id="username" placeholder="Username" required />
        <input type="password" id="password" placeholder="Password" required />
        <button type="submit" id="loginButton">Login</button>
      </form>
    </div>
    <script>
      const form = document.getElementById("loginForm");
      const messageDiv = document.getElementById("message");
      const loginButton = document.getElementById("loginButton");
      form.addEventListener("submit", async (e) => {
        e.preventDefault();
        const username = document.getElementById("username").value;
        const password = document.getElementById("password").value;
        // Disable button during request
        loginButton.disabled = true;
        loginButton.textContent = "Logging in...";
        try {
          const response = await fetch("/api/login", {
            method: "POST",
            headers: {
              "Content-Type": "application/json",
            },
            body: JSON.stringify({ username, password }),
          });
          const data = await response.json();
          if (response.ok) {
            showMessage(data.message, "success");
            // Store token in localStorage
            localStorage.setItem("access_token", data.access_token);
            localStorage.setItem("username", data.username);
            // Redirect based on is_admin from login response
            setTimeout(() => {
              if (data.is_admin === true) {
                window.location.href = "/admin.html";
              } else {
                window.location.href = "/";
              }
            }, 1000);
          } else {
            showMessage(data.detail || "Login failed", "error");
          }
        } catch (error) {
          showMessage("Network error. Please try again.", "error");
        } finally {
          loginButton.disabled = false;
          loginButton.textContent = "Login";
        }
      });
      function showMessage(text, type) {
        messageDiv.textContent = text;
        messageDiv.className = `message ${type}`;
        messageDiv.classList.remove("hidden");
      }
    </script>
  </body>
 </html>
@@ -0,0 +1,383 @@
 <!doctype html>
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Baby Monitor - Register</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: 450px;
        width: 100%;
      }
      h1 {
        color: #333;
        margin-bottom: 10px;
        font-size: 28px;
        text-align: center;
      }
      .subtitle {
        color: #666;
        margin-bottom: 30px;
        font-size: 14px;
        text-align: center;
      }
      .form-group {
        margin-bottom: 20px;
      }
      label {
        display: block;
        margin-bottom: 8px;
        color: #444;
        font-weight: 600;
        font-size: 14px;
      }
      input {
        width: 100%;
        padding: 12px;
        border: 2px solid #e0e0e0;
        border-radius: 6px;
        font-size: 16px;
        transition: border-color 0.3s;
      }
      input:focus {
        outline: none;
        border-color: #667eea;
      }
      .button {
        width: 100%;
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        color: white;
        border: none;
        padding: 14px;
        border-radius: 6px;
        font-size: 16px;
        font-weight: 600;
        cursor: pointer;
        transition:
          transform 0.2s,
          box-shadow 0.2s;
        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;
      }
      .error {
        background: #ffebee;
        border-left: 4px solid #f44336;
        color: #c62828;
        padding: 12px;
        border-radius: 4px;
        margin-bottom: 20px;
        display: none;
        font-size: 14px;
      }
      .error.show {
        display: block;
      }
      .success {
        background: #e8f5e9;
        border-left: 4px solid #4caf50;
        color: #2e7d32;
        padding: 12px;
        border-radius: 4px;
        margin-bottom: 20px;
        display: none;
        font-size: 14px;
      }
      .success.show {
        display: block;
      }
      .loading-container {
        text-align: center;
        padding: 40px;
      }
      .spinner {
        border: 3px solid #f3f3f3;
        border-top: 3px solid #667eea;
        border-radius: 50%;
        width: 40px;
        height: 40px;
        animation: spin 1s linear infinite;
        margin: 0 auto 20px;
      }
      @keyframes spin {
        0% {
          transform: rotate(0deg);
        }
        100% {
          transform: rotate(360deg);
        }
      }
      .info-box {
        background: #e7f3ff;
        border-left: 4px solid #2196f3;
        padding: 12px;
        border-radius: 4px;
        margin-bottom: 20px;
        font-size: 14px;
        color: #555;
      }
      .hidden {
        display: none;
      }
      .password-requirements {
        font-size: 12px;
        color: #666;
        margin-top: 5px;
      }
      .password-requirements ul {
        margin: 5px 0 0 20px;
      }
    </style>
  </head>
  <body>
    <div class="container">
      <div id="loadingContainer" class="loading-container">
        <div class="spinner"></div>
        <p style="color: #666">Validating invitation...</p>
      </div>
      <div id="registerContainer" class="hidden">
        <h1>🎉 Create Your Account</h1>
        <p class="subtitle">Complete the registration to get started</p>
        <div id="error" class="error"></div>
        <div id="success" class="success"></div>
        <form id="registerForm" onsubmit="handleRegister(event)">
          <div class="form-group">
            <label for="username">Username</label>
            <input
              type="text"
              id="username"
              name="username"
              required
              minlength="3"
              autocomplete="username"
              placeholder="Choose a username"
            />
          </div>
          <div class="form-group">
            <label for="password">Password</label>
            <input
              type="password"
              id="password"
              name="password"
              required
              minlength="8"
              autocomplete="new-password"
              placeholder="Choose a strong password"
            />
            <div class="password-requirements">
              <ul>
                <li>At least 8 characters long</li>
                <li>Mix of letters, numbers recommended</li>
              </ul>
            </div>
          </div>
          <div class="form-group">
            <label for="confirmPassword">Confirm Password</label>
            <input
              type="password"
              id="confirmPassword"
              name="confirmPassword"
              required
              minlength="8"
              autocomplete="new-password"
              placeholder="Re-enter your password"
            />
          </div>
          <button type="submit" class="button" id="submitBtn">
            Create Account
          </button>
        </form>
      </div>
      <div id="invalidTokenContainer" class="hidden">
        <h1>⚠️ Invalid Invitation</h1>
        <p class="subtitle">This invitation link is invalid or has expired</p>
        <div class="info-box">
          This could mean:
          <ul style="margin: 10px 0 0 20px; color: #555">
            <li>The invitation has already been used</li>
            <li>The invitation has expired (24 hours)</li>
            <li>The invitation link is incorrect</li>
          </ul>
        </div>
        <p style="text-align: center; color: #666; margin-top: 20px">
          Please contact an administrator for a new invitation link.
        </p>
      </div>
    </div>
    <script>
      let invitationToken = null;
      // Extract token from URL query parameters
      const urlParams = new URLSearchParams(window.location.search);
      invitationToken = urlParams.get("token");
      // Validate token on page load
      window.addEventListener("DOMContentLoaded", async () => {
        if (!invitationToken) {
          showInvalidToken();
          return;
        }
        try {
          // Verify the invitation token
          const response = await fetch(
            `/api/verify-invitation?token=${encodeURIComponent(invitationToken)}`,
          );
          if (response.ok) {
            showRegisterForm();
          } else {
            showInvalidToken();
          }
        } catch (error) {
          console.error("Error validating invitation:", error);
          showInvalidToken();
        }
      });
      function showRegisterForm() {
        document.getElementById("loadingContainer").classList.add("hidden");
        document.getElementById("registerContainer").classList.remove("hidden");
      }
      function showInvalidToken() {
        document.getElementById("loadingContainer").classList.add("hidden");
        document
          .getElementById("invalidTokenContainer")
          .classList.remove("hidden");
      }
      async function handleRegister(event) {
        event.preventDefault();
        const username = document.getElementById("username").value;
        const password = document.getElementById("password").value;
        const confirmPassword =
          document.getElementById("confirmPassword").value;
        const errorDiv = document.getElementById("error");
        const successDiv = document.getElementById("success");
        const submitBtn = document.getElementById("submitBtn");
        // Clear previous messages
        errorDiv.classList.remove("show");
        successDiv.classList.remove("show");
        // Validate passwords match
        if (password !== confirmPassword) {
          errorDiv.textContent = "Passwords do not match!";
          errorDiv.classList.add("show");
          return;
        }
        // Disable submit button
        submitBtn.disabled = true;
        submitBtn.textContent = "Creating Account...";
        try {
          const response = await fetch("/api/register", {
            method: "POST",
            headers: {
              "Content-Type": "application/json",
            },
            body: JSON.stringify({
              username: username,
              password: password,
              invitation_token: invitationToken,
            }),
          });
          const data = await response.json();
          if (response.ok) {
            // Store the access token and username
            localStorage.setItem("access_token", data.access_token);
            localStorage.setItem("username", data.username);
            // Show success message
            successDiv.textContent =
              "Account created successfully! Redirecting...";
            successDiv.classList.add("show");
            // Redirect to home page after a brief delay
            setTimeout(() => {
              window.location.href = "/";
            }, 1500);
          } else {
            errorDiv.textContent =
              data.detail || "Registration failed. Please try again.";
            errorDiv.classList.add("show");
            submitBtn.disabled = false;
            submitBtn.textContent = "Create Account";
          }
        } catch (error) {
          console.error("Registration error:", error);
          errorDiv.textContent = "An error occurred. Please try again.";
          errorDiv.classList.add("show");
          submitBtn.disabled = false;
          submitBtn.textContent = "Create Account";
        }
      }
    </script>
  </body>
 </html>
@@ -0,0 +1,33 @@
 """Password hashing utilities using bcrypt."""
 import bcrypt
 def hash_password(password: str) -> str:
    """Hash a password using bcrypt.
    Args:
        password: Plain text password to hash
    Returns:
        Hashed password as a string
    """
    salt = bcrypt.gensalt()
    hashed: bytes = bcrypt.hashpw(password.encode("utf-8"), salt)
    return hashed.decode("utf-8")
 def verify_password(password: str, hashed_password: str) -> bool:
    """Verify a password against a hashed password.
    Args:
        password: Plain text password to verify
        hashed_password: Previously hashed password
    Returns:
        True if password matches, False otherwise
    """
    result: bool = bcrypt.checkpw(
        password.encode("utf-8"), hashed_password.encode("utf-8")
    )
    return result
@@ -0,0 +1,20 @@
 """Root conftest for all tests."""
 import os
 import tempfile
 import pytest
 def pytest_configure(config: pytest.Config) -> None:
    """Configure pytest environment before any imports happen."""
    # Set DATA_DIR before any modules are imported
    if "DATA_DIR" not in os.environ:
        tmpdir = tempfile.mkdtemp(prefix="baby_monitor_test_")
        os.environ["DATA_DIR"] = tmpdir
        os.environ["ENVIRONMENT"] = "development"
    # Set admin credentials for tests
    if "ADMIN_USERNAME" not in os.environ:
        os.environ["ADMIN_USERNAME"] = "admin"
    if "ADMIN_PASSWORD" not in os.environ:
        os.environ["ADMIN_PASSWORD"] = "password"
@@ -1,28 +1,14 @@
 """Integration tests configuration."""
-import os
+from collections.abc import Iterator
 from typing import Iterator
 import pytest
 from fastapi.testclient import TestClient
@pytest.fixture(scope="session", autouse=True)
 def set_test_environment() -> Iterator[None]:
    """Set environment to development for all integration tests."""
    original_env = os.environ.get("ENVIRONMENT")
    os.environ["ENVIRONMENT"] = "development"
    yield
    # Cleanup: restore original environment
    if original_env is None:
        os.environ.pop("ENVIRONMENT", None)
    else:
        os.environ["ENVIRONMENT"] = original_env
@pytest.fixture(scope="session")
 def app_test_client() -> Iterator[TestClient]:
    """Provides a TestClient for the FastAPI app."""
-    # Import here after environment is set
+    # Import after environment is set by root conftest
    from baby_monitor.main import app
    with TestClient(app) as client:
@@ -0,0 +1,171 @@
 """Integration tests for FastAPI application."""
 import pytest
 from fastapi.testclient import TestClient
@pytest.mark.integration
 def test_home_page_serves_html(app_test_client: TestClient) -> None:
    """Test root endpoint returns HTML page."""
    response = app_test_client.get("/")
    assert response.status_code == 200
    assert "text/html" in response.headers["content-type"]
@pytest.mark.integration
 def test_api_root_requires_auth(app_test_client: TestClient) -> None:
    """Test API root endpoint requires authentication."""
    response = app_test_client.get("/api/")
    assert response.status_code == 401
    assert response.json() == {"detail": "Not authenticated"}
@pytest.mark.integration
 def test_api_root_with_auth(app_test_client: TestClient) -> None:
    """Test authenticated API root endpoint returns expected message."""
    # First login to get token
    login_response = app_test_client.post(
        "/api/login", json={"username": "admin", "password": "password"}
    )
    assert login_response.status_code == 200
    token = login_response.json()["access_token"]
    # Then access API root with token
    response = app_test_client.get(
        "/api/", headers={"Authorization": f"Bearer {token}"}
    )
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World", "authenticated": True}
@pytest.mark.integration
 def test_health_check(app_test_client: TestClient) -> None:
    """Test health check endpoint returns healthy status."""
    response = app_test_client.get("/health")
    assert response.status_code == 200
    assert response.json() == {"status": "healthy"}
@pytest.mark.integration
 def test_readiness_check(app_test_client: TestClient) -> None:
    """Test readiness check endpoint returns ready status."""
    response = app_test_client.get("/ready")
    assert response.status_code == 200
    assert response.json() == {"status": "ready"}
@pytest.mark.integration
 def test_openapi_docs_accessible(app_test_client: TestClient) -> None:
    """Test OpenAPI documentation is accessible."""
    response = app_test_client.get("/docs")
    assert response.status_code == 200
@pytest.mark.integration
 def test_openapi_json_accessible(app_test_client: TestClient) -> None:
    """Test OpenAPI JSON schema is accessible."""
    response = app_test_client.get("/openapi.json")
    assert response.status_code == 200
    assert "openapi" in response.json()
    assert "info" in response.json()
@pytest.mark.integration
 def test_nonexistent_endpoint_returns_404(app_test_client: TestClient) -> None:
    """Test requesting a non-existent endpoint returns 404."""
    response = app_test_client.get("/nonexistent")
    assert response.status_code == 404
@pytest.mark.integration
 def test_root_endpoint_content_type(app_test_client: TestClient) -> None:
    """Test root endpoint returns HTML content type."""
    response = app_test_client.get("/")
    assert "text/html" in response.headers["content-type"]
@pytest.mark.integration
 def test_api_root_endpoint_content_type(app_test_client: TestClient) -> None:
    """Test API root endpoint returns JSON content type."""
    # Login first to get token
    login_response = app_test_client.post(
        "/api/login", json={"username": "admin", "password": "password"}
    )
    token = login_response.json()["access_token"]
    response = app_test_client.get(
        "/api/", headers={"Authorization": f"Bearer {token}"}
    )
    assert response.headers["content-type"] == "application/json"
@pytest.mark.integration
 def test_health_endpoint_content_type(app_test_client: TestClient) -> None:
    """Test health endpoint returns JSON content type."""
    response = app_test_client.get("/health")
    assert response.headers["content-type"] == "application/json"
@pytest.mark.integration
 def test_ready_endpoint_content_type(app_test_client: TestClient) -> None:
    """Test readiness endpoint returns JSON content type."""
    response = app_test_client.get("/ready")
    assert response.headers["content-type"] == "application/json"
@pytest.mark.integration
 def test_login_success(app_test_client: TestClient) -> None:
    """Test successful login returns access token."""
    response = app_test_client.post(
        "/api/login", json={"username": "admin", "password": "password"}
    )
    assert response.status_code == 200
    data = response.json()
    assert "access_token" in data
    assert data["token_type"] == "bearer"
@pytest.mark.integration
 def test_login_invalid_credentials(app_test_client: TestClient) -> None:
    """Test login with invalid credentials returns 401."""
    response = app_test_client.post(
        "/api/login", json={"username": "admin", "password": "wrongpassword"}
    )
    assert response.status_code == 401
    assert response.json() == {"detail": "Invalid username or password"}
@pytest.mark.integration
 def test_login_missing_fields(app_test_client: TestClient) -> None:
    """Test login with missing fields returns validation error."""
    response = app_test_client.post("/api/login", json={"username": "admin"})
    assert response.status_code == 422
@pytest.mark.integration
 def test_logout(app_test_client: TestClient) -> None:
    """Test logout endpoint."""
    # Login first
    login_response = app_test_client.post(
        "/api/login", json={"username": "admin", "password": "password"}
    )
    token = login_response.json()["access_token"]
    # Logout
    response = app_test_client.post(
        "/api/logout", headers={"Authorization": f"Bearer {token}"}
    )
    assert response.status_code == 200
    assert response.json() == {"message": "Logged out successfully"}
@pytest.mark.integration
 def test_info_endpoint(app_test_client: TestClient) -> None:
    """Test info endpoint returns installed features."""
    response = app_test_client.get("/info")
    assert response.status_code == 200
    data = response.json()
    assert "features" in data
    assert isinstance(data["features"], dict)
    assert "redis" in data["features"]
    assert "postgresql" in data["features"]
@@ -1,72 +0,0 @@
 """Integration tests for FastAPI application."""
 import pytest
 from fastapi.testclient import TestClient
@pytest.mark.integration
 def test_read_root(app_test_client: TestClient) -> None:
    """Test root endpoint returns expected message."""
    response = app_test_client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}
@pytest.mark.integration
 def test_health_check(app_test_client: TestClient) -> None:
    """Test health check endpoint returns healthy status."""
    response = app_test_client.get("/health")
    assert response.status_code == 200
    assert response.json() == {"status": "healthy"}
@pytest.mark.integration
 def test_readiness_check(app_test_client: TestClient) -> None:
    """Test readiness check endpoint returns ready status."""
    response = app_test_client.get("/ready")
    assert response.status_code == 200
    assert response.json() == {"status": "ready"}
@pytest.mark.integration
 def test_openapi_docs_accessible(app_test_client: TestClient) -> None:
    """Test OpenAPI documentation is accessible."""
    response = app_test_client.get("/docs")
    assert response.status_code == 200
@pytest.mark.integration
 def test_openapi_json_accessible(app_test_client: TestClient) -> None:
    """Test OpenAPI JSON schema is accessible."""
    response = app_test_client.get("/openapi.json")
    assert response.status_code == 200
    assert "openapi" in response.json()
    assert "info" in response.json()
@pytest.mark.integration
 def test_nonexistent_endpoint_returns_404(app_test_client: TestClient) -> None:
    """Test requesting a non-existent endpoint returns 404."""
    response = app_test_client.get("/nonexistent")
    assert response.status_code == 404
@pytest.mark.integration
 def test_root_endpoint_content_type(app_test_client: TestClient) -> None:
    """Test root endpoint returns JSON content type."""
    response = app_test_client.get("/")
    assert response.headers["content-type"] == "application/json"
@pytest.mark.integration
 def test_health_endpoint_content_type(app_test_client: TestClient) -> None:
    """Test health endpoint returns JSON content type."""
    response = app_test_client.get("/health")
    assert response.headers["content-type"] == "application/json"
@pytest.mark.integration
 def test_ready_endpoint_content_type(app_test_client: TestClient) -> None:
    """Test readiness endpoint returns JSON content type."""
    response = app_test_client.get("/ready")
    assert response.headers["content-type"] == "application/json"
@@ -0,0 +1,139 @@
 """Unit tests for database module."""
 from pathlib import Path
 from sqlalchemy.orm import Session
 from baby_monitor.repositories.dependencies.get_database import get_database, init_db
 def test_get_db_yields_session() -> None:
    """Test that get_db yields a valid database session."""
    init_db()
    db_generator = get_database()
    db = next(db_generator)
    assert isinstance(db, Session)
    assert db.is_active
    # Close the session
    try:
        next(db_generator)
    except StopIteration:
        pass
 def test_get_db_closes_session() -> None:
    """Test that get_db properly closes the session."""
    from unittest.mock import patch
    init_db()
    db_generator = get_database()
    db = next(db_generator)
    assert db.is_active
    # Patch the close method to verify it gets called
    with patch.object(db, "close", wraps=db.close) as mock_close:
        # Complete the generator to trigger finally block
        try:
            next(db_generator)
        except StopIteration:
            pass
        # Verify that close() was called
        mock_close.assert_called_once()
 def test_get_db_closes_on_exception() -> None:
    """Test that get_db closes session when used in context manager."""
    from unittest.mock import patch
    init_db()
    # Simulate how FastAPI actually uses the dependency
    db = None
    db_generator = get_database()
    try:
        db = next(db_generator)
        assert db.is_active
        # Patch close to verify it gets called even with an exception
        with patch.object(db, "close", wraps=db.close) as mock_close:
            try:
                # Simulate an exception occurring during request processing
                raise ValueError("Simulated error during request")
            except ValueError:
                pass
            finally:
                # FastAPI ensures the generator completes
                try:
                    next(db_generator)
                except StopIteration:
                    pass
            # Verify close() was called despite the exception
            mock_close.assert_called_once()
    except Exception:
        # Ensure we have a reference to db for the final assertion
        pass
    # Verify db was created
    assert db is not None
 # def test_init_db_creates_directory(tmp_path: Path) -> None:
 #     """Test that init_db creates the data directory."""
 #     import os
 #     # Use a fresh temp directory for this test
 #     test_dir = tmp_path / "test_data"
 #     # Reinitialize database module with new path
 #     from baby_monitor.repositories.dependencies.get_database import (
 #         DATA_DIR,
 #         DATABASE_URL,
 #         create_engine,
 #         sessionmaker,
 #     )
 #     DATABASE_URL = f"sqlite:///{test_dir}/baby_monitor.db"
 #     engine = create_engine(
 #         DATABASE_URL,
 #         connect_args={"check_same_thread": False},
 #         echo=False,
 #     )
 #     SessionLocal = sessionmaker(
 #         autocommit=False,
 #         autoflush=False,
 #         bind=engine
 #     )
 #     init_db()
 #     assert isinstance(SessionLocal, sessionmaker)
 #     assert test_dir.exists()
 #     assert test_dir.is_dir()
 def test_init_db_creates_tables(tmp_path: Path) -> None:
    """Test that init_db creates database tables."""
    init_db()
    # Check that database file exists
    import os
    data_dir = Path(os.environ["DATA_DIR"])
    db_path = data_dir / "baby_monitor.db"
    assert db_path.exists()
    # Verify tables were created by checking metadata
    from baby_monitor.repositories.dependencies.get_database import engine
    from sqlalchemy import inspect
    inspector = inspect(engine)
    tables = inspector.get_table_names()
    # Should have at least some tables (depends on models)
    # For now, just verify the function runs without error
    assert isinstance(tables, list)
@@ -39,36 +39,121 @@ name = "baby-monitor"
 version = "0.1.0"
 source = { editable = "." }
 dependencies = [
    { name = "bcrypt" },
    { name = "fastapi" },
    { name = "sqlalchemy" },
    { name = "uvicorn" },
 ]
 [package.optional-dependencies]
 postgres = [
    { name = "psycopg2-binary" },
 ]
 redis = [
    { name = "redis" },
 ]
 [package.dev-dependencies]
 dev = [
    { name = "httpx" },
    { name = "mypy" },
    { name = "pre-commit" },
    { name = "prettier" },
    { name = "pytest" },
    { name = "pytest-cov" },
    { name = "pyupgrade" },
    { name = "ruff" },
    { name = "types-psycopg2" },
 ]
 [package.metadata]
 requires-dist = [
    { name = "bcrypt", specifier = ">=4.0.0" },
    { name = "fastapi", specifier = ">=0.121.0" },
    { name = "psycopg2-binary", marker = "extra == 'postgres'", specifier = ">=2.9.0" },
    { name = "redis", marker = "extra == 'redis'", specifier = ">=5.0.0" },
    { name = "sqlalchemy", specifier = ">=2.0.0" },
    { name = "uvicorn", specifier = ">=0.38.0" },
 ]
 provides-extras = ["redis", "postgres"]
 [package.metadata.requires-dev]
 dev = [
    { name = "httpx", specifier = ">=0.28.1" },
    { name = "mypy", specifier = ">=1.18.2" },
    { name = "pre-commit", specifier = ">=4.3.0" },
    { name = "prettier", specifier = ">=0.0.7" },
    { name = "pytest", specifier = ">=8.4.2" },
    { name = "pytest-cov", specifier = ">=7.0.0" },
    { name = "pyupgrade", specifier = ">=3.21.0" },
    { name = "ruff", specifier = ">=0.14.3" },
    { name = "types-psycopg2", specifier = ">=2.9.21.20251012" },
 ]
 [[package]]
 name = "bcrypt"
 version = "5.0.0"
 source = { registry = "http://10.0.0.2:5001/index/" }
 sdist = { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0.tar.gz", hash = "sha256:f748f7c2d6fd375cc93d3fba7ef4a9e3a092421b8dbf34d8d4dc06be9492dfdd" }
 wheels = [
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-macosx_10_12_universal2.whl", hash = "sha256:f3c08197f3039bec79cee59a606d62b96b16669cff3949f21e74796b6e3cd2be" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:200af71bc25f22006f4069060c88ed36f8aa4ff7f53e67ff04d2ab3f1e79a5b2" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:baade0a5657654c2984468efb7d6c110db87ea63ef5a4b54732e7e337253e44f" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c58b56cdfb03202b3bcc9fd8daee8e8e9b6d7e3163aa97c631dfcfcc24d36c86" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bfd2a34de661f34d0bda43c3e4e79df586e4716ef401fe31ea39d69d581ef23" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ed2e1365e31fc73f1825fa830f1c8f8917ca1b3ca6185773b349c20fd606cec2" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_aarch64.whl", hash = "sha256:83e787d7a84dbbfba6f250dd7a5efd689e935f03dd83b0f919d39349e1f23f83" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_x86_64.whl", hash = "sha256:137c5156524328a24b9fac1cb5db0ba618bc97d11970b39184c1d87dc4bf1746" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:38cac74101777a6a7d3b3e3cfefa57089b5ada650dce2baf0cbdd9d65db22a9e" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:d8d65b564ec849643d9f7ea05c6d9f0cd7ca23bdd4ac0c2dbef1104ab504543d" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:741449132f64b3524e95cd30e5cd3343006ce146088f074f31ab26b94e6c75ba" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:212139484ab3207b1f0c00633d3be92fef3c5f0af17cad155679d03ff2ee1e41" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-win32.whl", hash = "sha256:9d52ed507c2488eddd6a95bccee4e808d3234fa78dd370e24bac65a21212b861" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f6984a24db30548fd39a44360532898c33528b74aedf81c26cf29c51ee47057e" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9fffdb387abe6aa775af36ef16f55e318dcda4194ddbf82007a6f21da29de8f5" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-macosx_10_12_universal2.whl", hash = "sha256:4870a52610537037adb382444fefd3706d96d663ac44cbb2f37e3919dca3d7ef" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48f753100931605686f74e27a7b49238122aa761a9aefe9373265b8b7aa43ea4" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f70aadb7a809305226daedf75d90379c397b094755a710d7014b8b117df1ebbf" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:744d3c6b164caa658adcb72cb8cc9ad9b4b75c7db507ab4bc2480474a51989da" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a28bc05039bdf3289d757f49d616ab3efe8cf40d8e8001ccdd621cd4f98f4fc9" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7f277a4b3390ab4bebe597800a90da0edae882c6196d3038a73adf446c4f969f" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:79cfa161eda8d2ddf29acad370356b47f02387153b11d46042e93a0a95127493" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a5393eae5722bcef046a990b84dff02b954904c36a194f6cfc817d7dca6c6f0b" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7f4c94dec1b5ab5d522750cb059bb9409ea8872d4494fd152b53cca99f1ddd8c" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0cae4cb350934dfd74c020525eeae0a5f79257e8a201c0c176f4b84fdbf2a4b4" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-win32.whl", hash = "sha256:b17366316c654e1ad0306a6858e189fc835eca39f7eb2cafd6aaca8ce0c40a2e" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:92864f54fb48b4c718fc92a32825d0e42265a627f956bc0361fe869f1adc3e7d" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dd19cf5184a90c873009244586396a6a884d591a5323f0e8a5922560718d4993" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-macosx_10_12_universal2.whl", hash = "sha256:fc746432b951e92b58317af8e0ca746efe93e66555f1b40888865ef5bf56446b" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c2388ca94ffee269b6038d48747f4ce8df0ffbea43f31abfa18ac72f0218effb" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:560ddb6ec730386e7b3b26b8b4c88197aaed924430e7b74666a586ac997249ef" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d79e5c65dcc9af213594d6f7f1fa2c98ad3fc10431e7aa53c176b441943efbdd" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2b732e7d388fa22d48920baa267ba5d97cca38070b69c0e2d37087b381c681fd" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0c8e093ea2532601a6f686edbc2c6b2ec24131ff5c52f7610dd64fa4553b5464" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5b1589f4839a0899c146e8892efe320c0fa096568abd9b95593efac50a87cb75" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:89042e61b5e808b67daf24a434d89bab164d4de1746b37a8d173b6b14f3db9ff" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e3cf5b2560c7b5a142286f69bde914494b6d8f901aaa71e453078388a50881c4" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f632fd56fc4e61564f78b46a2269153122db34988e78b6be8b32d28507b7eaeb" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:801cad5ccb6b87d1b430f183269b94c24f248dddbbc5c1f78b6ed231743e001c" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3cf67a804fc66fc217e6914a5635000259fbbbb12e78a99488e4d5ba445a71eb" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-win32.whl", hash = "sha256:3abeb543874b2c0524ff40c57a4e14e5d3a66ff33fb423529c88f180fd756538" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-win_amd64.whl", hash = "sha256:35a77ec55b541e5e583eb3436ffbbf53b0ffa1fa16ca6782279daf95d146dcd9" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp38-abi3-win_arm64.whl", hash = "sha256:cde08734f12c6a4e28dc6755cd11d3bdfea608d93d958fffbe95a7026ebe4980" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:0c418ca99fd47e9c59a301744d63328f17798b5947b0f791e9af3c1c499c2d0a" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddb4e1500f6efdd402218ffe34d040a1196c072e07929b9820f363a1fd1f4191" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7aeef54b60ceddb6f30ee3db090351ecf0d40ec6e2abf41430997407a46d2254" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f0ce778135f60799d89c9693b9b398819d15f1921ba15fe719acb3178215a7db" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a71f70ee269671460b37a449f5ff26982a6f2ba493b3eabdd687b4bf35f875ac" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f8429e1c410b4073944f03bd778a9e066e7fad723564a52ff91841d278dfc822" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:edfcdcedd0d0f05850c52ba3127b1fce70b9f89e0fe5ff16517df7e81fa3cbb8" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:611f0a17aa4a25a69362dcc299fda5c8a3d4f160e2abb3831041feb77393a14a" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:db99dca3b1fdc3db87d7c57eac0c82281242d1eabf19dcb8a6b10eb29a2e72d1" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:5feebf85a9cefda32966d8171f5db7e3ba964b77fdfe31919622256f80f9cf42" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3ca8a166b1140436e058298a34d88032ab62f15aae1c598580333dc21d27ef10" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:61afc381250c3182d9078551e3ac3a41da14154fbff647ddf52a769f588c4172" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-win32.whl", hash = "sha256:64d7ce196203e468c457c37ec22390f1a61c85c6f0b8160fd752940ccfb3a683" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:64ee8434b0da054d830fa8e89e1c8bf30061d539044a39524ff7dec90481e5c2" },
    { url = "http://10.0.0.2:5001/index/bcrypt/bcrypt-5.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:f2347d3534e76bf50bca5500989d6c1d05ed64b440408057a37673282c654927" },
 ]
 [[package]]
@@ -217,6 +302,45 @@ wheels = [
    { url = "http://10.0.0.2:5001/index/filelock/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2" },
 ]
 [[package]]
 name = "greenlet"
 version = "3.2.4"
 source = { registry = "http://10.0.0.2:5001/index/" }
 sdist = { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4.tar.gz", hash = "sha256:0dca0d95ff849f9a364385f36ab49f50065d76964944638be9691e1832e9f86d" }
 wheels = [
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3b67ca49f54cede0186854a008109d6ee71f66bd57bb36abd6d0a0267b540cdd" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddf9164e7a5b08e9d22511526865780a576f19ddd00d62f8a665949327fde8bb" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f28588772bb5fb869a8eb331374ec06f24a83a9c25bfa1f38b6993afe9c1e968" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:5c9320971821a7cb77cfab8d956fa8e39cd07ca44b6070db358ceb7f8797c8c9" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c60a6d84229b271d44b70fb6e5fa23781abb5d742af7b808ae3f6efd7c9c60f6" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b3812d8d0c9579967815af437d96623f45c0f2ae5f04e366de62a12d83a8fb0" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:abbf57b5a870d30c4675928c37278493044d7c14378350b3aa5d484fa65575f0" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:20fb936b4652b6e307b8f347665e2c615540d4b42b3b4c8a321d8286da7e520f" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee7a6ec486883397d70eec05059353b8e83eca9168b9f3f9a361971e77e0bcd0" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:326d234cbf337c9c3def0676412eb7040a35a768efc92504b947b3e9cfc7543d" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:a7d4e128405eea3814a12cc2605e0e6aedb4035bf32697f72deca74de4105e02" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:1a921e542453fe531144e91e1feedf12e07351b1cf6c9e8a3325ea600a715a31" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd3c8e693bff0fff6ba55f140bf390fa92c994083f838fece0f63be121334945" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:710638eb93b1fa52823aa91bf75326f9ecdfd5e0466f00789246a5280f4ba0fc" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:c5111ccdc9c88f423426df3fd1811bfc40ed66264d35aa373420a34377efc98a" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76383238584e9711e20ebe14db6c88ddcedc1829a9ad31a584389463b5aa504" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23768528f2911bcd7e475210822ffb5254ed10d71f4028387e5a99b4c6699671" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:00fadb3fedccc447f517ee0d3fd8fe49eae949e1cd0f6a611818f4f6fb7dc83b" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:d25c5091190f2dc0eaa3f950252122edbbadbb682aa7b1ef2f8af0f8c0afefae" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e343822feb58ac4d0a1211bd9399de2b3a04963ddeec21530fc426cc121f19b" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca7f6f1f2649b89ce02f6f229d7c19f680a6238af656f61e0115b24857917929" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:554b03b6e73aaabec3745364d6239e9e012d64c68ccd0b8430c64ccc14939a8b" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:49a30d5fda2507ae77be16479bdb62a660fa51b1eb4928b524975b3bde77b3c0" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:299fd615cd8fc86267b47597123e3f43ad79c9d8a22bebdce535e53550763e2f" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:c17b6b34111ea72fc5a4e4beec9711d2226285f0386ea83477cbb97c30a3f3a5" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b4a1870c51720687af7fa3e7cda6d08d801dae660f75a76f3845b642b4da6ee1" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:061dc4cf2c34852b052a8620d40f36324554bc192be474b9e9770e8c042fd735" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44358b9bf66c8576a9f57a590d5f5d6e72fa4228b763d0e43fee6d3b06d3a337" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2917bdf657f5859fbf3386b12d68ede4cf1f04c90c3a6bc1f013dd68a22e2269" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:015d48959d4add5d6c9f6c5210ee3803a830dce46356e3bc326d6776bde54681" },
    { url = "http://10.0.0.2:5001/index/greenlet/greenlet-3.2.4-cp314-cp314-win_amd64.whl", hash = "sha256:e37ab26028f12dbb0ff65f29a8d3d44a765c61e729647bf2ddfbbed621726f01" },
 ]
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -383,6 +507,56 @@ wheels = [
    { url = "http://10.0.0.2:5001/index/pre-commit/pre_commit-4.3.0-py2.py3-none-any.whl", hash = "sha256:2b0747ad7e6e967169136edffee14c16e148a778a54e4f967921aa1ebf2308d8" },
 ]
 [[package]]
 name = "prettier"
 version = "0.0.7"
 source = { registry = "http://10.0.0.2:5001/index/" }
 sdist = { url = "http://10.0.0.2:5001/index/prettier/prettier-0.0.7.tar.gz", hash = "sha256:6c34b8cd09fd9c8956c05d6395ea3f575e0122dce494ba57685c07065abed427" }
 wheels = [
    { url = "http://10.0.0.2:5001/index/prettier/prettier-0.0.7-py3-none-any.whl", hash = "sha256:20e76791de41cafe481328dd49552303f29ca192151cee1b120c26f66cae9bfc" },
 ]
 [[package]]
 name = "psycopg2-binary"
 version = "2.9.11"
 source = { registry = "http://10.0.0.2:5001/index/" }
 sdist = { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2-binary-2.9.11.tar.gz", hash = "sha256:b6aed9e096bf63f9e75edf2581aa9a7e7186d97ab5c177aa6c87797cd591236c" }
 wheels = [
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:be9b840ac0525a283a96b556616f5b4820e0526addb8dcf6525a0fa162730be4" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f090b7ddd13ca842ebfe301cd587a76a4cf0913b1e429eb92c1be5dbeb1a19bc" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ab8905b5dcb05bf3fb22e0cf90e10f469563486ffb6a96569e51f897c750a76a" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:bf940cd7e7fec19181fdbc29d76911741153d51cab52e5c21165f3262125685e" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fa0f693d3c68ae925966f0b14b8edda71696608039f4ed61b1fe9ffa468d16db" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a1cf393f1cdaf6a9b57c0a719a1068ba1069f022a59b8b1fe44b006745b59757" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7a6beb4beaa62f88592ccc65df20328029d721db309cb3250b0aae0fa146c3" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:31b32c457a6025e74d233957cc9736742ac5a6cb196c6b68499f6bb51390bd6a" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:edcb3aeb11cb4bf13a2af3c53a15b3d612edeb6409047ea0b5d6a21a9d744b34" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:62b6d93d7c0b61a1dd6197d208ab613eb7dcfdcca0a49c42ceb082257991de9d" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp312-cp312-win_amd64.whl", hash = "sha256:b33fabeb1fde21180479b2d4667e994de7bbf0eec22832ba5d9b5e4cf65b6c6d" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b8fb3db325435d34235b044b199e56cdf9ff41223a4b9752e8576465170bb38c" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:366df99e710a2acd90efed3764bb1e28df6c675d33a7fb40df9b7281694432ee" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8c55b385daa2f92cb64b12ec4536c66954ac53654c7f15a203578da4e78105c0" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:c0377174bf1dd416993d16edc15357f6eb17ac998244cca19bc67cdc0e2e5766" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5c6ff3335ce08c75afaed19e08699e8aacf95d4a260b495a4a8545244fe2ceb3" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:84011ba3109e06ac412f95399b704d3d6950e386b7994475b231cf61eec2fc1f" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ba34475ceb08cccbdd98f6b46916917ae6eeb92b5ae111df10b544c3a4621dc4" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b31e90fdd0f968c2de3b26ab014314fe814225b6c324f770952f7d38abf17e3c" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:d526864e0f67f74937a8fce859bd56c979f5e2ec57ca7c627f5f1071ef7fee60" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04195548662fa544626c8ea0f06561eb6203f1984ba5b4562764fbeb4c3d14b1" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp313-cp313-win_amd64.whl", hash = "sha256:efff12b432179443f54e230fdf60de1f6cc726b6c832db8701227d089310e8aa" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:92e3b669236327083a2e33ccfa0d320dd01b9803b3e14dd986a4fc54aa00f4e1" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e0deeb03da539fa3577fcb0b3f2554a97f7e5477c246098dbb18091a4a01c16f" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b52a3f9bb540a3e4ec0f6ba6d31339727b2950c9772850d6545b7eae0b9d7c5" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:db4fd476874ccfdbb630a54426964959e58da4c61c9feba73e6094d51303d7d8" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:47f212c1d3be608a12937cc131bd85502954398aaa1320cb4c14421a0ffccf4c" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e35b7abae2b0adab776add56111df1735ccc71406e56203515e228a8dc07089f" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fcf21be3ce5f5659daefd2b3b3b6e4727b028221ddc94e6c1523425579664747" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:9bd81e64e8de111237737b29d68039b9c813bdf520156af36d26819c9a979e5f" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:32770a4d666fbdafab017086655bcddab791d7cb260a16679cc5a7338b64343b" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c3cb3a676873d7506825221045bd70e0427c905b9c8ee8d6acd70cfcbd6e576d" },
    { url = "http://10.0.0.2:5001/index/psycopg2-binary/psycopg2_binary-2.9.11-cp314-cp314-win_amd64.whl", hash = "sha256:4012c9c954dfaccd28f94e84ab9f94e12df76b4afb22331b1f0d3154893a6316" },
 ]
 [[package]]
 name = "pydantic"
 version = "2.12.3"
@@ -562,6 +736,15 @@ wheels = [
    { url = "http://10.0.0.2:5001/index/pyyaml/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b" },
 ]
 [[package]]
 name = "redis"
 version = "7.0.1"
 source = { registry = "http://10.0.0.2:5001/index/" }
 sdist = { url = "http://10.0.0.2:5001/index/redis/redis-7.0.1.tar.gz", hash = "sha256:c949df947dca995dc68fdf5a7863950bf6df24f8d6022394585acc98e81624f1" }
 wheels = [
    { url = "http://10.0.0.2:5001/index/redis/redis-7.0.1-py3-none-any.whl", hash = "sha256:4977af3c7d67f8f0eb8b6fec0dafc9605db9343142f634041fb0235f67c0588a" },
 ]
 [[package]]
 name = "ruff"
 version = "0.14.3"
@@ -597,6 +780,35 @@ wheels = [
    { url = "http://10.0.0.2:5001/index/sniffio/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" },
 ]
 [[package]]
 name = "sqlalchemy"
 version = "2.0.44"
 source = { registry = "http://10.0.0.2:5001/index/" }
 dependencies = [
    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
    { name = "typing-extensions" },
 ]
 sdist = { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44.tar.gz", hash = "sha256:0ae7454e1ab1d780aee69fd2aae7d6b8670a581d8847f2d1e0f7ddfbf47e5a22" }
 wheels = [
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72fea91746b5890f9e5e0997f16cbf3d53550580d76355ba2d998311b17b2250" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:585c0c852a891450edbb1eaca8648408a3cc125f18cf433941fa6babcc359e29" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b94843a102efa9ac68a7a30cd46df3ff1ed9c658100d30a725d10d9c60a2f44" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:119dc41e7a7defcefc57189cfa0e61b1bf9c228211aba432b53fb71ef367fda1" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0765e318ee9179b3718c4fd7ba35c434f4dd20332fbc6857a5e8df17719c24d7" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2e7b5b079055e02d06a4308d0481658e4f06bc7ef211567edc8f7d5dce52018d" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp312-cp312-win32.whl", hash = "sha256:846541e58b9a81cce7dee8329f352c318de25aa2f2bbe1e31587eb1f057448b4" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp312-cp312-win_amd64.whl", hash = "sha256:7cbcb47fd66ab294703e1644f78971f6f2f1126424d2b300678f419aa73c7b6e" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ff486e183d151e51b1d694c7aa1695747599bb00b9f5f604092b54b74c64a8e1" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0b1af8392eb27b372ddb783b317dea0f650241cea5bd29199b22235299ca2e45" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2b61188657e3a2b9ac4e8f04d6cf8e51046e28175f79464c67f2fd35bceb0976" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b87e7b91a5d5973dda5f00cd61ef72ad75a1db73a386b62877d4875a8840959c" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:15f3326f7f0b2bfe406ee562e17f43f36e16167af99c4c0df61db668de20002d" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e77faf6ff919aa8cd63f1c4e561cac1d9a454a191bb864d5dd5e545935e5a40" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp313-cp313-win32.whl", hash = "sha256:ee51625c2d51f8baadf2829fae817ad0b66b140573939dd69284d2ba3553ae73" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-cp313-cp313-win_amd64.whl", hash = "sha256:c1c80faaee1a6c3428cecf40d16a2365bcf56c424c92c2b6f0f9ad204b899e9e" },
    { url = "http://10.0.0.2:5001/index/sqlalchemy/sqlalchemy-2.0.44-py3-none-any.whl", hash = "sha256:19de7ca1246fbef9f9d1bff8f1ab25641569df226364a0e40457dc5457c54b05" },
 ]
 [[package]]
 name = "starlette"
 version = "0.49.3"
@@ -619,6 +831,15 @@ wheels = [
    { url = "http://10.0.0.2:5001/index/tokenize-rt/tokenize_rt-6.2.0-py2.py3-none-any.whl", hash = "sha256:a152bf4f249c847a66497a4a95f63376ed68ac6abf092a2f7cfb29d044ecff44" },
 ]
 [[package]]
 name = "types-psycopg2"
 version = "2.9.21.20251012"
 source = { registry = "http://10.0.0.2:5001/index/" }
 sdist = { url = "http://10.0.0.2:5001/index/types-psycopg2/types_psycopg2-2.9.21.20251012.tar.gz", hash = "sha256:4cdafd38927da0cfde49804f39ab85afd9c6e9c492800e42f1f0c1a1b0312935" }
 wheels = [
    { url = "http://10.0.0.2:5001/index/types-psycopg2/types_psycopg2-2.9.21.20251012-py3-none-any.whl", hash = "sha256:712bad5c423fe979e357edbf40a07ca40ef775d74043de72bd4544ca328cc57e" },
 ]
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"
Author	SHA1	Message	Date
brian	edeb01c889	Merge pull request 'added diaper overview page' (#16 ) from add-diaper-change-overview into main Python Code Quality / python-code-quality (push) Successful in 9s Details Python Test / python-test (push) Successful in 17s Details Build and Push Docker Image / build-and-push (push) Successful in 25s Details Reviewed-on: #16	2025-11-10 16:26:43 +01:00
Brian Bjarke Jensen	cf3029b545	added diaper overview page Build and Push Docker Image / build-and-push (pull_request) Successful in 57s Details Python Code Quality / python-code-quality (pull_request) Successful in 10s Details Python Test / python-test (pull_request) Successful in 17s Details	2025-11-10 16:24:07 +01:00
brian	aaa84b8b1a	Merge pull request 'support-add-diaper-entry' (#13 ) from support-add-diaper-entry into main Python Test / python-test (push) Successful in 17s Details Build and Push Docker Image / build-and-push (push) Successful in 30s Details Python Code Quality / python-code-quality (push) Successful in 9s Details Reviewed-on: #13	2025-11-10 15:59:45 +01:00
Brian Bjarke Jensen	e9e5936267	removed unused text Build and Push Docker Image / build-and-push (pull_request) Successful in 1m6s Details Python Code Quality / python-code-quality (pull_request) Successful in 10s Details Python Test / python-test (pull_request) Successful in 17s Details	2025-11-10 15:56:57 +01:00
Brian Bjarke Jensen	788b473c23	added functionality to log diaper changes	2025-11-10 15:56:08 +01:00
Brian Bjarke Jensen	0853ff0ff4	corrected postgres uri	2025-11-10 15:55:26 +01:00
brian	8fe3694e7a	Merge pull request 'add-feeding-overview' (#12 ) from add-feeding-overview into main Python Code Quality / python-code-quality (push) Successful in 9s Details Python Test / python-test (push) Successful in 17s Details Build and Push Docker Image / build-and-push (push) Successful in 25s Details Reviewed-on: #12	2025-11-10 00:23:09 +01:00
Brian Bjarke Jensen	3582ba13e8	made example deployments for different environments Build and Push Docker Image / build-and-push (pull_request) Successful in 25s Details Python Code Quality / python-code-quality (pull_request) Successful in 10s Details Python Test / python-test (pull_request) Successful in 17s Details	2025-11-10 00:21:19 +01:00
Brian Bjarke Jensen	44c6f0168f	added feedings page with graphs and list of entries with option to edit and manually add new Build and Push Docker Image / build-and-push (pull_request) Successful in 58s Details Python Code Quality / python-code-quality (pull_request) Successful in 10s Details Python Test / python-test (pull_request) Successful in 17s Details	2025-11-09 21:23:09 +01:00
Brian Bjarke Jensen	8d5e2a99ef	removed deprecated yaml field	2025-11-09 19:12:49 +01:00
brian	af2c3ed264	Merge pull request 'added feeding data objects and workflow' (#10 ) from support-add-feeding-entry into main Build and Push Docker Image / build-and-push (push) Successful in 25s Details Python Code Quality / python-code-quality (push) Successful in 10s Details Python Test / python-test (push) Successful in 17s Details Reviewed-on: #10	2025-11-09 19:10:45 +01:00
Brian Bjarke Jensen	55de11dcdd	added feeding data objects and workflow Build and Push Docker Image / build-and-push (pull_request) Successful in 57s Details Python Code Quality / python-code-quality (pull_request) Successful in 10s Details Python Test / python-test (pull_request) Successful in 17s Details	2025-11-09 17:22:37 +01:00
brian	1f48083db8	Merge pull request 'make-page-to-add-child' (#9 ) from make-page-to-add-child into main Build and Push Docker Image / build-and-push (push) Successful in 26s Details Python Code Quality / python-code-quality (push) Successful in 10s Details Python Test / python-test (push) Successful in 17s Details Reviewed-on: #9	2025-11-09 12:47:06 +01:00
Brian Bjarke Jensen	16e7153f5f	added child endpoint, ability to add and edit child as well as auto redirect to add-child page when user without child accesses home page Build and Push Docker Image / build-and-push (pull_request) Successful in 1m5s Details Python Code Quality / python-code-quality (pull_request) Successful in 10s Details Python Test / python-test (pull_request) Successful in 17s Details	2025-11-09 11:54:28 +01:00
Brian Bjarke Jensen	1950b600cf	added clarifying comment	2025-11-09 11:19:03 +01:00
brian	b883ef455b	Merge pull request 'added password hashing and ensured admin user exists' (#8 ) from add-password-hashing into main Build and Push Docker Image / build-and-push (push) Successful in 28s Details Python Code Quality / python-code-quality (push) Successful in 10s Details Python Test / python-test (push) Successful in 17s Details Reviewed-on: #8	2025-11-08 00:04:43 +01:00
Brian Bjarke Jensen	19a211121c	formatting fixes Build and Push Docker Image / build-and-push (pull_request) Successful in 58s Details Python Code Quality / python-code-quality (pull_request) Successful in 10s Details Python Test / python-test (pull_request) Successful in 17s Details	2025-11-07 23:56:38 +01:00
Brian Bjarke Jensen	ef1c7f83b6	added admin credential env vars for testing	2025-11-07 23:56:15 +01:00
Brian Bjarke Jensen	7b4e597e6f	added password hashing and ensured admin user exists Build and Push Docker Image / build-and-push (pull_request) Successful in 58s Details Python Code Quality / python-code-quality (pull_request) Failing after 10s Details Python Test / python-test (pull_request) Failing after 24s Details	2025-11-07 23:48:14 +01:00
brian	8b187f134d	Merge pull request 'support-adding-users' (#4 ) from support-adding-users into main Build and Push Docker Image / build-and-push (push) Successful in 25s Details Python Code Quality / python-code-quality (push) Successful in 10s Details Python Test / python-test (push) Successful in 15s Details Reviewed-on: #4	2025-11-07 23:14:38 +01:00
Brian Bjarke Jensen	2b956213aa	ruff and prettier fixes Build and Push Docker Image / build-and-push (pull_request) Successful in 1m6s Details Python Code Quality / python-code-quality (pull_request) Successful in 10s Details Python Test / python-test (pull_request) Successful in 15s Details	2025-11-07 23:10:59 +01:00
Brian Bjarke Jensen	469fd722de	mypy fixes	2025-11-07 23:10:25 +01:00
Brian Bjarke Jensen	9d9bab56ed	removed admin link from burger menu	2025-11-07 23:05:40 +01:00
Brian Bjarke Jensen	43971a1eea	added admin login redirect to admin dashboard	2025-11-07 23:04:21 +01:00
Brian Bjarke Jensen	d31ebc8c22	added burger menu with admin page and user invitation link generation	2025-11-07 22:33:57 +01:00
Brian Bjarke Jensen	b8e04fe816	corrected gitea instance links Build and Push Docker Image / build-and-push (push) Successful in 56s Details Python Code Quality / python-code-quality (push) Successful in 9s Details Python Test / python-test (push) Successful in 14s Details	2025-11-06 23:41:51 +01:00
Brian Bjarke Jensen	c2d272d7ac	prettier fixes	2025-11-06 23:37:55 +01:00
Brian Bjarke Jensen	f15e87a484	added prettier	2025-11-06 23:37:35 +01:00
Brian Bjarke Jensen	705a89e16e	added readme Build and Push Docker Image / build-and-push (push) Successful in 59s Details Python Code Quality / python-code-quality (push) Successful in 10s Details Python Test / python-test (push) Successful in 14s Details	2025-11-06 22:46:40 +01:00
Brian Bjarke Jensen	c3a08372a0	changed to using secret for repeated variable Python Code Quality / python-code-quality (push) Successful in 10s Details Python Test / python-test (push) Successful in 14s Details Build and Push Docker Image / build-and-push (push) Successful in 25s Details	2025-11-06 22:15:14 +01:00
Brian Bjarke Jensen	d953564986	formatting fixes Build and Push Docker Image / build-and-push (push) Failing after 15s Details Python Code Quality / python-code-quality (push) Successful in 9s Details Python Test / python-test (push) Successful in 14s Details	2025-11-06 22:08:07 +01:00
Brian Bjarke Jensen	0e247a69b0	formatting fixes Build and Push Docker Image / build-and-push (push) Failing after 23s Details Python Code Quality / python-code-quality (push) Failing after 9s Details Python Test / python-test (push) Successful in 15s Details	2025-11-06 22:06:41 +01:00
Brian Bjarke Jensen	41636cce77	updated tests	2025-11-06 22:06:34 +01:00
Brian Bjarke Jensen	b36f5eb183	added ignore for local test db	2025-11-06 21:40:12 +01:00
Brian Bjarke Jensen	68aedc6f43	aligned docker files	2025-11-06 21:34:04 +01:00
Brian Bjarke Jensen	de13beb48b	added convenience docs	2025-11-06 21:33:51 +01:00
Brian Bjarke Jensen	5baea47185	updated available endpoints	2025-11-06 21:33:35 +01:00
Brian Bjarke Jensen	a22de7cef9	added data models	2025-11-06 21:33:13 +01:00
Brian Bjarke Jensen	28305eb36f	added repositories with dependency injection	2025-11-06 21:32:56 +01:00
Brian Bjarke Jensen	c0266acb18	added fastapi endpoint routers	2025-11-06 21:32:02 +01:00
Brian Bjarke Jensen	37625f2e76	added login and home page	2025-11-06 21:31:11 +01:00
Brian Bjarke Jensen	6b0982b369	updated author info	2025-11-06 21:30:45 +01:00
Brian Bjarke Jensen	607a202a19	renamed test file	2025-11-06 20:05:01 +01:00
Brian Bjarke Jensen	b1bb2ca4bb	added CI to build docker image	2025-11-06 20:04:24 +01:00
Brian Bjarke Jensen	29fd7b4656	added support for postgres and redis	2025-11-06 20:03:32 +01:00
		`@@ -0,0 +1,3 @@`
							`from .auth import LoginRequest, LoginResponse`

							`__all__ = ["LoginRequest", "LoginResponse"]`