Check in service

.env.example

@@ -4,3 +4,27 @@ DEBUG=false
 LOG_LEVEL=INFO
 PORT=8003
 ROOT_PATH=
+
+# MongoDB Configuration
+MONGODB_URI=mongodb+srv://username:password@cluster0.2shrc.mongodb.net/?retryWrites=true&w=majority
+MONGODB_DB_NAME=cuatrolabs
+
+# PostgreSQL Configuration
+DB_PROTOCOL=postgresql+asyncpg
+DB_USER=postgres
+DB_PASSWORD=your-db-password
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=cuatrolabs
+DB_MIN_POOL_SIZE=5
+DB_MAX_POOL_SIZE=20
+DB_SSLMODE=disable
+DATABASE_URL=postgresql+asyncpg://postgres:your-db-password@localhost:5432/cuatrolabs
+
+# JWT Configuration
+SECRET_KEY=your-secret-key-here-change-in-production
+ALGORITHM=HS256
+TOKEN_EXPIRATION_HOURS=8
+
+# CORS Settings
+CORS_ORIGINS=["http://localhost:3000","http://localhost:8000","http://localhost:8003"]

.gitignore

@@ -0,0 +1,76 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.venv
+
+# Environment variables
+.env.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.hypothesis/
+
+# Logs
+*.log
+logs/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+.env
+
+# Debug and test scripts
+debug_*.py
+test_conversion.py
+test_dependency.py
+test_endpoint_direct.py
+update_system_users.py
+update_system_users.js
+
+# MinIO data directory
+minio-data/
+
+#MD Files
+*.md
+app/insightfy_utils-0.1.0-py3-none-any.whl
+test_token.txt
+get-pip.py
+generate_test_token.py
+generate_test_request.py

README.md

@@ -1,11 +1,272 @@
----
-title: Cuatrolabs Tracker Ms
-emoji: 🌖
-colorFrom: blue
-colorTo: yellow
-sdk: docker
-pinned: false
-short_description: Employee Tracker
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Tracker Microservice
+
+Employee tracking and attendance management microservice for the Cuatro Labs platform.
+
+## Features
+
+### Attendance Management
+- Employee check-in with GPS coordinates
+- Location tracking consent validation
+- Geofence detection support
+- Duplicate check-in prevention
+- Daily attendance records
+
+## Architecture
+
+### Technology Stack
+- **Framework**: FastAPI 0.104.1
+- **Database**: 
+  - MongoDB (employee data, location settings)
+  - PostgreSQL (attendance records)
+- **Authentication**: JWT-based
+- **Server**: Uvicorn with async support
+
+### Project Structure
+```
+app/
+├── core/
+│   ├── config.py           # Configuration settings
+│   ├── logging.py          # Logging setup
+│   └── database.py         # SQLAlchemy base
+├── dependencies/
+│   └── auth.py             # JWT authentication
+├── tracker/
+│   └── attendance/
+│       ├── models.py       # SQLAlchemy models
+│       ├── schemas.py      # Pydantic schemas
+│       ├── service.py      # Business logic
+│       ├── router.py       # API endpoints
+│       └── constants.py    # Constants
+├── main.py                 # Application entry point
+├── nosql.py                # MongoDB connection
+└── postgres.py             # PostgreSQL connection pool
+```
+
+## API Endpoints
+
+### Attendance Endpoints
+
+#### Check-In
+**POST** `/api/v1/attendance/check-in`
+
+Mark the start of an employee's working day.
+
+**Request Body:**
+```json
+{
+  "timestamp": 1708156800000,
+  "latitude": 19.0760,
+  "longitude": 72.8777,
+  "location_id": "loc_mumbai_office_001"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "message": "Check-in successful"
+}
+```
+
+**Rules:**
+- Can check-in only once per day
+- Location coordinates are mandatory
+- GPS tracking must be enabled (checked from MongoDB)
+- Optional location_id if inside a geofence
+
+**Edge Cases:**
+- Duplicate check-in → 400 error
+- GPS disabled → 400 error
+
+## Database Schema
+
+### PostgreSQL - trans.scm_attendance
+
+```sql
+CREATE TABLE trans.scm_attendance (
+    id UUID PRIMARY KEY,
+    merchant_id UUID NOT NULL,
+    employee_id UUID NOT NULL,
+    work_date DATE NOT NULL,
+    check_in_time BIGINT,
+    check_in_lat DOUBLE PRECISION,
+    check_in_lon DOUBLE PRECISION,
+    check_in_geofence_id UUID,
+    check_out_time BIGINT,
+    check_out_lat DOUBLE PRECISION,
+    check_out_lon DOUBLE PRECISION,
+    total_minutes INTEGER,
+    created_at TIMESTAMP DEFAULT now(),
+    updated_at TIMESTAMP DEFAULT now(),
+    UNIQUE (employee_id, work_date)
+);
+
+CREATE INDEX idx_scm_attendance_work_date 
+ON trans.scm_attendance (employee_id, work_date);
+
+CREATE INDEX idx_scm_attendance_merchant 
+ON trans.scm_attendance (merchant_id, work_date);
+```
+
+### MongoDB - scm_employees
+
+Location tracking consent is checked from:
+```
+scm_employees.location_settings.location_tracking_consent
+```
+
+## Environment Configuration
+
+Copy `.env.example` to `.env` and configure:
+
+```bash
+# Application
+APP_NAME=Tracker Microservice
+APP_VERSION=1.0.0
+DEBUG=false
+LOG_LEVEL=INFO
+PORT=8003
+
+# MongoDB
+MONGODB_URI=mongodb+srv://username:password@cluster0.2shrc.mongodb.net/?retryWrites=true&w=majority
+MONGODB_DB_NAME=cuatrolabs
+
+# PostgreSQL
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=cuatrolabs
+DB_USER=postgres
+DB_PASSWORD=your-password
+DATABASE_URL=postgresql+asyncpg://postgres:password@localhost:5432/cuatrolabs
+
+# JWT
+SECRET_KEY=your-secret-key-change-in-production
+ALGORITHM=HS256
+TOKEN_EXPIRATION_HOURS=8
+```
+
+## Getting Started
+
+### Prerequisites
+- Python 3.11+
+- MongoDB (Atlas or local)
+- PostgreSQL
+
+### Local Development
+
+1. Create and activate virtual environment:
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Configure environment:
+```bash
+cp .env.example .env
+# Edit .env with your configuration
+```
+
+4. Run the service:
+```bash
+uvicorn app.main:app --host 0.0.0.0 --port 8003 --reload
+```
+
+5. Access API documentation:
+- Swagger UI: http://localhost:8003/docs
+- ReDoc: http://localhost:8003/redoc
+
+### Docker Deployment
+
+```bash
+# Build the image
+docker build -t tracker-microservice .
+
+# Run the container
+docker run -p 8003:8003 --env-file .env tracker-microservice
+```
+
+## Testing
+
+### Manual Testing with curl
+
+```bash
+# Health check
+curl http://localhost:8003/health
+
+# Check-in (requires JWT token)
+curl -X POST http://localhost:8003/api/v1/attendance/check-in \
+  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "timestamp": 1708156800000,
+    "latitude": 19.0760,
+    "longitude": 72.8777,
+    "location_id": "loc_mumbai_office_001"
+  }'
+```
+
+## Error Handling
+
+The service provides structured error responses:
+
+**400 Bad Request** - Business logic errors
+```json
+{
+  "success": false,
+  "error": "Already checked in today",
+  "detail": "You have already checked in for today"
+}
+```
+
+**401 Unauthorized** - Invalid or missing JWT token
+```json
+{
+  "success": false,
+  "error": "Unauthorized",
+  "detail": "Invalid or expired token"
+}
+```
+
+**422 Validation Error** - Invalid request data
+```json
+{
+  "success": false,
+  "error": "Validation Error",
+  "errors": [
+    {
+      "field": "latitude",
+      "message": "Latitude must be between -90 and 90",
+      "type": "value_error"
+    }
+  ]
+}
+```
+
+**500 Internal Server Error** - Unexpected errors
+```json
+{
+  "success": false,
+  "error": "Internal Server Error",
+  "detail": "An unexpected error occurred"
+}
+```
+
+## Logging
+
+The service uses structured JSON logging with the following levels:
+- DEBUG: Detailed diagnostic information
+- INFO: General informational messages
+- WARNING: Warning messages for recoverable issues
+- ERROR: Error messages for failures
+- CRITICAL: Critical errors requiring immediate attention
+
+## License
+
+Part of the Cuatro Labs platform.

app/core/config.py

@@ -2,7 +2,9 @@
 Configuration settings for Tracker microservice.
 Loads environment variables and provides application settings.
 """
-from typing import List
+import os
+from typing import Optional, List
+from pydantic import model_validator, Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -14,6 +16,69 @@ class Settings(BaseSettings):
     APP_VERSION: str = "1.0.0"
     DEBUG: bool = False
 
+    # MongoDB Configuration
+    MONGODB_URI: str = "mongodb://localhost:27017"
+    MONGODB_DB_NAME: str = "cuatrolabs"
+
+    # PostgreSQL Configuration
+    # Let Pydantic handle environment variables - don't use os.getenv() here!
+    # Use Field with alias to map DB_HOST -> POSTGRES_HOST, etc.
+    POSTGRES_HOST: str = Field(default="localhost", validation_alias="DB_HOST")
+    POSTGRES_PORT: int = Field(default=5432, validation_alias="DB_PORT")
+    POSTGRES_DB: str = Field(default="cuatrolabs", validation_alias="DB_NAME")
+    POSTGRES_USER: str = Field(default="postgres", validation_alias="DB_USER")
+    POSTGRES_PASSWORD: str = Field(default="", validation_alias="DB_PASSWORD")
+    POSTGRES_MIN_POOL_SIZE: int = 5
+    POSTGRES_MAX_POOL_SIZE: int = 20
+    POSTGRES_CONNECT_MAX_RETRIES: int = 20
+    POSTGRES_CONNECT_INITIAL_DELAY_MS: int = 500
+    POSTGRES_CONNECT_BACKOFF_MULTIPLIER: float = 1.5
+    POSTGRES_SSL_MODE: str = Field(default="disable", validation_alias="DB_SSLMODE")
+    POSTGRES_SSL_ROOT_CERT: Optional[str] = None
+    POSTGRES_SSL_CERT: Optional[str] = None
+    POSTGRES_SSL_KEY: Optional[str] = None
+    POSTGRES_URI: Optional[str] = None
+
+    @model_validator(mode='after')
+    def assemble_db_connection(self) -> 'Settings':
+        from urllib.parse import quote_plus
+        # Prefer DATABASE_URL and DATABASE_URI
+        env_url = (os.getenv("DATABASE_URL") or os.getenv("DATABASE_URI") or "").strip()
+        if env_url:
+            self.POSTGRES_URI = env_url
+            print(f"[CONFIG] Using provided DATABASE_URL/URI")
+            return self
+        # Build DSN from individual parts
+        if all([self.POSTGRES_USER, self.POSTGRES_PASSWORD, self.POSTGRES_HOST, self.POSTGRES_DB]):
+            protocol = os.getenv("DB_PROTOCOL", "postgresql+asyncpg")
+            # Ensure no spaces in connection components
+            user = self.POSTGRES_USER.strip()
+            host = self.POSTGRES_HOST.strip()
+            port = str(self.POSTGRES_PORT).strip()
+            db = self.POSTGRES_DB.strip()
+            self.POSTGRES_URI = f"{protocol}://{user}:{quote_plus(self.POSTGRES_PASSWORD)}@{host}:{port}/{db}"
+            print(f"[CONFIG] Built POSTGRES_URI from components")
+            print(f"[CONFIG]   Protocol: {protocol}")
+            print(f"[CONFIG]   User: {self.POSTGRES_USER}")
+            print(f"[CONFIG]   Host: {self.POSTGRES_HOST}")
+            print(f"[CONFIG]   Port: {self.POSTGRES_PORT}")
+            print(f"[CONFIG]   Database: {self.POSTGRES_DB}")
+            print(f"[CONFIG]   Password: {'SET' if self.POSTGRES_PASSWORD else 'EMPTY'}")
+            print(f"[CONFIG]   SSL Mode: {self.POSTGRES_SSL_MODE}")
+        else:
+            self.POSTGRES_URI = None
+            print(f"[CONFIG] ERROR: Cannot build POSTGRES_URI - missing required components")
+            print(f"[CONFIG]   POSTGRES_USER: {'SET' if self.POSTGRES_USER else 'MISSING'}")
+            print(f"[CONFIG]   POSTGRES_PASSWORD: {'SET' if self.POSTGRES_PASSWORD else 'MISSING'}")
+            print(f"[CONFIG]   POSTGRES_HOST: {'SET' if self.POSTGRES_HOST else 'MISSING'}")
+            print(f"[CONFIG]   POSTGRES_DB: {'SET' if self.POSTGRES_DB else 'MISSING'}")
+        return self
+
+    # JWT Configuration
+    SECRET_KEY: str = "your-secret-key-change-in-production"
+    ALGORITHM: str = "HS256"
+    TOKEN_EXPIRATION_HOURS: int = 8
+
     # Logging
     LOG_LEVEL: str = "INFO"
 
@@ -21,6 +86,7 @@ class Settings(BaseSettings):
     CORS_ORIGINS: List[str] = [
         "http://localhost:3000",
         "http://localhost:8000",
+        "http://localhost:8003",
     ]
 
     # Pydantic v2 config
@@ -28,7 +94,12 @@ class Settings(BaseSettings):
         env_file=".env",
         env_file_encoding="utf-8",
         case_sensitive=True,
-        extra="allow",
+        extra="allow",  # allows extra environment variables without error
+        # Priority order (highest to lowest):
+        # 1. OS environment variables (Docker, shell exports)
+        # 2. .env file (local development)
+        # 3. Default values (fallback)
+        env_prefix="",  # No prefix, use exact names
     )
 
 

app/core/database.py

@@ -0,0 +1,7 @@
+"""
+Shared database configuration and base classes.
+"""
+from sqlalchemy.orm import declarative_base
+
+# Shared Base for all SQLAlchemy models
+Base = declarative_base()

app/core/logging.py

@@ -0,0 +1,56 @@
+"""
+Logging configuration for Tracker microservice.
+"""
+import logging
+import sys
+from typing import Optional
+
+try:
+    from insightfy_utils.logging import get_logger as _insight_get_logger
+    from insightfy_utils.logging import setup_logging as _insight_setup_logging
+except Exception:
+    _insight_get_logger = None
+    _insight_setup_logging = None
+
+
+def setup_logging(
+    level: str = "INFO",
+    format_type: str = "colored",
+    app_name: Optional[str] = None,
+    include_correlation: bool = True
+) -> None:
+    """
+    Configure logging for the application.
+    Uses insightfy_utils logging when available, falls back to standard logging.
+    """
+    if _insight_setup_logging:
+        _insight_setup_logging(
+            level=level,
+            format_type=format_type,
+            app_name=app_name or "tracker-microservice",
+            include_correlation=include_correlation
+        )
+        return
+
+    # Fallback to standard logging
+    log_level = getattr(logging, level.upper(), logging.INFO)
+    logging.basicConfig(
+        level=log_level,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[logging.StreamHandler(sys.stdout)]
+    )
+    
+    # Set specific log levels for noisy libraries
+    logging.getLogger("motor").setLevel(logging.WARNING)
+    logging.getLogger("pymongo").setLevel(logging.WARNING)
+    logging.getLogger("asyncpg").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance"""
+    if _insight_get_logger:
+        return _insight_get_logger(name)
+    return logging.getLogger(name)

app/dependencies/__init__.py

@@ -0,0 +1,3 @@
+"""
+Dependencies module for Tracker microservice.
+"""

app/dependencies/auth.py

@@ -0,0 +1,85 @@
+"""
+Authentication dependencies for FastAPI.
+Validates JWT tokens and provides user context.
+"""
+from typing import Optional
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import JWTError, jwt
+from pydantic import BaseModel
+
+from app.core.config import settings
+
+security = HTTPBearer()
+
+
+class TokenUser(BaseModel):
+    """User information extracted from JWT token"""
+    user_id: str
+    username: str
+    role: str
+    merchant_id: str
+    merchant_type: Optional[str] = None
+    metadata: Optional[dict] = None
+    
+    def has_role(self, *roles: str) -> bool:
+        """Check if user has any of the specified roles"""
+        return self.role in roles
+    
+    def is_admin(self) -> bool:
+        """Check if user has admin privileges"""
+        return "admin" in self.role.lower()
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security)
+) -> TokenUser:
+    """
+    Get current authenticated user from JWT token.
+    Validates the token and extracts user information.
+    """
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    try:
+        # Decode and verify JWT token
+        payload = jwt.decode(
+            credentials.credentials,
+            settings.SECRET_KEY,
+            algorithms=[settings.ALGORITHM]
+        )
+        
+        user_id: str = payload.get("sub")
+        username: str = payload.get("username")
+        role: str = payload.get("role")
+        merchant_id: str = payload.get("merchant_id")
+        merchant_type: str = payload.get("merchant_type")
+        metadata: dict = payload.get("metadata")
+        
+        if user_id is None or username is None or merchant_id is None:
+            raise credentials_exception
+        
+        # Create TokenUser from payload
+        return TokenUser(
+            user_id=user_id,
+            username=username,
+            role=role or "user",
+            merchant_id=merchant_id,
+            merchant_type=merchant_type,
+            metadata=metadata
+        )
+        
+    except JWTError:
+        raise credentials_exception
+    except Exception:
+        raise credentials_exception
+
+
+async def get_current_active_user(
+    current_user: TokenUser = Depends(get_current_user)
+) -> TokenUser:
+    """Get current active user."""
+    return current_user

app/main.py

@@ -1,64 +1,224 @@
 """
 Main FastAPI application for Tracker Microservice.
 """
-import logging
 import os
-from fastapi import FastAPI
+from fastapi import FastAPI, Request, status
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+from jose import JWTError
 
 from app.core.config import settings
-from app.tracker.controllers.router import router as tracker_router
+from app.core.logging import setup_logging, get_logger
+from app.nosql import connect_to_mongo, close_mongo_connection
+from app.postgres import connect_to_postgres, close_postgres_connection
+from app.tracker.attendance.router import router as attendance_router
 
-logging.basicConfig(level=getattr(logging, settings.LOG_LEVEL.upper(), logging.INFO))
-logger = logging.getLogger(__name__)
+# Initialize logging first
+log_level = getattr(settings, 'LOG_LEVEL', 'INFO').strip().upper()
+if log_level not in ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']:
+    log_level = 'INFO'
 
+setup_logging(
+    level=log_level,
+    format_type="colored",
+    app_name="tracker-microservice",
+    include_correlation=True
+)
+logger = get_logger(__name__)
+
+# Create FastAPI app
 app = FastAPI(
     title=settings.APP_NAME,
-    description="Employee Tracker - Basic service scaffold",
+    description="Employee Tracker - Attendance and Location Tracking",
     version=settings.APP_VERSION,
     docs_url="/docs",
     redoc_url="/redoc",
     root_path=os.getenv("ROOT_PATH", ""),
 )
 
+# CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=settings.CORS_ORIGINS,
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
+    expose_headers=["*"],
 )
 
 
+# Startup and shutdown events
 @app.on_event("startup")
 async def startup_event():
+    """Initialize connections on startup"""
     logger.info("Starting Tracker Microservice")
+    await connect_to_mongo()
+    await connect_to_postgres()
+    
+    # Create schema and tables
+    try:
+        from app.tracker.attendance.models import ScmAttendance
+        conn = None
+        try:
+            from app.postgres import get_postgres_connection, release_postgres_connection
+            conn = await get_postgres_connection()
+            
+            # Create trans schema
+            await conn.execute("CREATE SCHEMA IF NOT EXISTS trans")
+            logger.info("✅ TRANS schema exists")
+            
+            # Create table
+            create_table_sql = """
+                CREATE TABLE IF NOT EXISTS trans.scm_attendance (
+                    id UUID PRIMARY KEY,
+                    merchant_id UUID NOT NULL,
+                    employee_id UUID NOT NULL,
+                    work_date DATE NOT NULL,
+                    check_in_time BIGINT,
+                    check_in_lat DOUBLE PRECISION,
+                    check_in_lon DOUBLE PRECISION,
+                    check_in_geofence_id UUID,
+                    check_out_time BIGINT,
+                    check_out_lat DOUBLE PRECISION,
+                    check_out_lon DOUBLE PRECISION,
+                    total_minutes INTEGER,
+                    created_at TIMESTAMP DEFAULT now(),
+                    updated_at TIMESTAMP DEFAULT now(),
+                    UNIQUE (employee_id, work_date)
+                )
+            """
+            await conn.execute(create_table_sql)
+            logger.info("✅ scm_attendance table created/verified")
+            
+            # Create indexes
+            index_sql = """
+                CREATE INDEX IF NOT EXISTS idx_scm_attendance_work_date
+                ON trans.scm_attendance (employee_id, work_date)
+            """
+            await conn.execute(index_sql)
+            
+            index_merchant_sql = """
+                CREATE INDEX IF NOT EXISTS idx_scm_attendance_merchant
+                ON trans.scm_attendance (merchant_id, work_date)
+            """
+            await conn.execute(index_merchant_sql)
+            logger.info("✅ Indexes created/verified")
+            
+        finally:
+            if conn:
+                await release_postgres_connection(conn)
+                
+    except Exception as e:
+        logger.error("Failed to create database schema", exc_info=e)
+        raise
+    
+    logger.info("Tracker Microservice started successfully")
 
 
 @app.on_event("shutdown")
 async def shutdown_event():
+    """Close connections on shutdown"""
     logger.info("Shutting down Tracker Microservice")
+    await close_mongo_connection()
+    await close_postgres_connection()
+    logger.info("Tracker Microservice shut down successfully")
 
 
+# Health check endpoint
 @app.get("/health", tags=["health"])
 async def health_check():
+    """Health check endpoint"""
     return {
         "status": "healthy",
         "service": "tracker-microservice",
-        "version": settings.APP_VERSION,
+        "version": settings.APP_VERSION
     }
 
 
-app.include_router(tracker_router, prefix="/api/v1")
+# Include routers
+app.include_router(attendance_router, prefix="/api/v1")
+
+
+# Global exception handlers
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    errors = [
+        {
+            "field": " -> ".join(str(loc) for loc in error["loc"]),
+            "message": error["msg"],
+            "type": error["type"]
+        }
+        for error in exc.errors()
+    ]
+    logger.warning(
+        "Validation error",
+        extra={
+            "path": request.url.path,
+            "method": request.method,
+            "error_count": len(errors),
+            "errors": errors
+        }
+    )
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content={
+            "success": False,
+            "error": "Validation Error",
+            "errors": errors
+        }
+    )
+
+
+@app.exception_handler(JWTError)
+async def jwt_exception_handler(request: Request, exc: JWTError):
+    logger.warning(
+        "JWT authentication failed",
+        extra={
+            "path": request.url.path,
+            "error": str(exc),
+            "client_ip": request.client.host if request.client else None
+        }
+    )
+    return JSONResponse(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        content={
+            "success": False,
+            "error": "Unauthorized",
+            "detail": "Invalid or expired token"
+        }
+    )
+
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    logger.error(
+        "Unhandled exception",
+        extra={
+            "method": request.method,
+            "path": request.url.path,
+            "error": str(exc),
+            "error_type": type(exc).__name__,
+            "client_ip": request.client.host if request.client else None
+        },
+        exc_info=True
+    )
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={
+            "success": False,
+            "error": "Internal Server Error",
+            "detail": "An unexpected error occurred"
+        }
+    )
 
 
 if __name__ == "__main__":
     import uvicorn
-
     uvicorn.run(
         "app.main:app",
         host="0.0.0.0",
         port=int(os.getenv("PORT", "8003")),
         reload=True,
-        log_level=settings.LOG_LEVEL.lower(),
+        log_level=log_level.lower()
     )

app/nosql.py

@@ -0,0 +1,87 @@
+"""
+MongoDB connection and database instance.
+Provides a singleton database connection for the application.
+"""
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+from app.core.logging import get_logger
+from app.core.config import settings
+
+logger = get_logger(__name__)
+
+
+class DatabaseConnection:
+    """Singleton class to manage MongoDB connection"""
+    _client: AsyncIOMotorClient = None
+    _db: AsyncIOMotorDatabase = None
+
+    @classmethod
+    def get_database(cls) -> AsyncIOMotorDatabase:
+        """
+        Get the database instance.
+        
+        Returns:
+            MongoDB database instance
+            
+        Raises:
+            RuntimeError if database is not connected
+        """
+        if cls._db is None:
+            raise RuntimeError("Database not connected. Call connect_to_mongo() first.")
+        return cls._db
+
+    @classmethod
+    async def connect(cls):
+        """
+        Establish connection to MongoDB.
+        Called during application startup.
+        """
+        try:
+            mongodb_uri = settings.MONGODB_URI.strip()
+            
+            logger.info("Connecting to MongoDB", extra={
+                "database": settings.MONGODB_DB_NAME
+            })
+
+            cls._client = AsyncIOMotorClient(
+                mongodb_uri,
+                uuidRepresentation="standard"
+            )
+            
+            cls._db = cls._client[settings.MONGODB_DB_NAME]
+            
+            # Test the connection
+            await cls._client.admin.command('ping')
+            
+            logger.info("Successfully connected to MongoDB", extra={
+                "database": settings.MONGODB_DB_NAME
+            })
+        except Exception as e:
+            logger.error("Failed to connect to MongoDB", exc_info=e)
+            raise
+
+    @classmethod
+    async def close(cls):
+        """
+        Close MongoDB connection.
+        Called during application shutdown.
+        """
+        if cls._client:
+            logger.info("Closing MongoDB connection")
+            cls._client.close()
+            logger.info("MongoDB connection closed")
+
+
+# Public API
+async def connect_to_mongo():
+    """Establish connection to MongoDB"""
+    await DatabaseConnection.connect()
+
+
+async def close_mongo_connection():
+    """Close MongoDB connection"""
+    await DatabaseConnection.close()
+
+
+def get_database() -> AsyncIOMotorDatabase:
+    """Get the database instance"""
+    return DatabaseConnection.get_database()

app/postgres.py

@@ -0,0 +1,175 @@
+"""
+PostgreSQL connection pool management.
+Provides async connection pool for PostgreSQL operations.
+"""
+import asyncpg
+import ssl
+from typing import Optional, Dict, Any
+from app.core.logging import get_logger
+from app.core.config import settings
+import time
+
+logger = get_logger(__name__)
+
+
+class PostgreSQLConnectionPool:
+    """Singleton class to manage PostgreSQL connection pool"""
+    _pool: Optional[asyncpg.Pool] = None
+    
+    _metrics = {
+        "connections_acquired": 0,
+        "connections_released": 0,
+        "connections_failed": 0,
+        "health_check_failures": 0,
+        "acquisition_times": [],
+    }
+
+    @classmethod
+    async def initialize(cls) -> None:
+        """Initialize PostgreSQL connection pool."""
+        if cls._pool is not None:
+            logger.warning("PostgreSQL connection pool already initialized")
+            return
+
+        try:
+            logger.info("Initializing PostgreSQL connection pool", extra={
+                "host": settings.POSTGRES_HOST,
+                "port": settings.POSTGRES_PORT,
+                "database": settings.POSTGRES_DB,
+                "user": settings.POSTGRES_USER,
+                "min_pool_size": settings.POSTGRES_MIN_POOL_SIZE,
+                "max_pool_size": settings.POSTGRES_MAX_POOL_SIZE
+            })
+
+            # Optional SSL context
+            ssl_context = None
+            mode = (settings.POSTGRES_SSL_MODE or "disable").lower()
+            if mode != "disable":
+                if mode == "verify-full":
+                    ssl_context = ssl.create_default_context()
+                    ssl_context.check_hostname = True
+                    ssl_context.verify_mode = ssl.CERT_REQUIRED
+                else:
+                    ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+                    ssl_context.check_hostname = False
+                    ssl_context.verify_mode = ssl.CERT_NONE
+                logger.info("PostgreSQL pool SSL enabled", extra={"ssl_mode": settings.POSTGRES_SSL_MODE})
+
+            # Create connection pool
+            cls._pool = await asyncpg.create_pool(
+                host=settings.POSTGRES_HOST,
+                port=settings.POSTGRES_PORT,
+                database=settings.POSTGRES_DB,
+                user=settings.POSTGRES_USER,
+                password=settings.POSTGRES_PASSWORD,
+                min_size=settings.POSTGRES_MIN_POOL_SIZE,
+                max_size=settings.POSTGRES_MAX_POOL_SIZE,
+                command_timeout=30.0,
+                timeout=30.0,
+                ssl=ssl_context,
+            )
+
+            # Test connection
+            async with cls._pool.acquire() as conn:
+                await conn.fetchval("SELECT 1")
+
+            logger.info("PostgreSQL connection pool initialized successfully")
+
+        except Exception as e:
+            logger.error("Failed to initialize PostgreSQL connection pool", exc_info=e)
+            raise
+
+    @classmethod
+    async def get_connection(cls) -> asyncpg.Connection:
+        """Acquire a connection from the pool."""
+        if cls._pool is None:
+            raise RuntimeError("PostgreSQL connection pool not initialized. Call initialize() first.")
+
+        start_time = time.time()
+        
+        try:
+            conn = await cls._pool.acquire()
+            
+            # Health check
+            try:
+                await conn.fetchval("SELECT 1")
+            except Exception as health_check_error:
+                logger.warning("Connection health check failed, releasing dead connection", 
+                             exc_info=health_check_error)
+                cls._metrics["health_check_failures"] += 1
+                await cls._pool.release(conn)
+                conn = await cls._pool.acquire()
+                await conn.fetchval("SELECT 1")
+            
+            acquisition_time = (time.time() - start_time) * 1000
+            cls._metrics["connections_acquired"] += 1
+            cls._metrics["acquisition_times"].append(acquisition_time)
+            
+            if len(cls._metrics["acquisition_times"]) > 1000:
+                cls._metrics["acquisition_times"] = cls._metrics["acquisition_times"][-1000:]
+            
+            return conn
+            
+        except Exception as e:
+            cls._metrics["connections_failed"] += 1
+            logger.error("Failed to acquire PostgreSQL connection", exc_info=e)
+            raise
+
+    @classmethod
+    async def release_connection(cls, conn: asyncpg.Connection) -> None:
+        """Release a connection back to the pool."""
+        if cls._pool is None:
+            raise RuntimeError("PostgreSQL connection pool not initialized")
+
+        try:
+            await cls._pool.release(conn)
+            cls._metrics["connections_released"] += 1
+        except Exception as e:
+            logger.error("Failed to release PostgreSQL connection", exc_info=e)
+
+    @classmethod
+    async def close(cls) -> None:
+        """Close all connections in the pool."""
+        if cls._pool is None:
+            logger.warning("PostgreSQL connection pool not initialized, nothing to close")
+            return
+
+        try:
+            logger.info("Closing PostgreSQL connection pool")
+            await cls._pool.close()
+            cls._pool = None
+            logger.info("PostgreSQL connection pool closed successfully")
+        except Exception as e:
+            logger.error("Error closing PostgreSQL connection pool", exc_info=e)
+            cls._pool = None
+
+    @classmethod
+    def is_initialized(cls) -> bool:
+        """Check if connection pool is initialized."""
+        return cls._pool is not None
+
+
+# Public API
+async def connect_to_postgres() -> None:
+    """Initialize PostgreSQL connection pool."""
+    await PostgreSQLConnectionPool.initialize()
+
+
+async def close_postgres_connection() -> None:
+    """Close PostgreSQL connection pool."""
+    await PostgreSQLConnectionPool.close()
+
+
+async def get_postgres_connection() -> asyncpg.Connection:
+    """Get a connection from the PostgreSQL pool."""
+    return await PostgreSQLConnectionPool.get_connection()
+
+
+async def release_postgres_connection(conn: asyncpg.Connection) -> None:
+    """Release a connection back to the pool."""
+    await PostgreSQLConnectionPool.release_connection(conn)
+
+
+def is_postgres_connected() -> bool:
+    """Check if PostgreSQL connection pool is initialized."""
+    return PostgreSQLConnectionPool.is_initialized()

app/tracker/attendance/__init__.py

@@ -0,0 +1,3 @@
+"""
+Attendance module for employee check-in/check-out tracking.
+"""

app/tracker/attendance/constants.py

@@ -0,0 +1,16 @@
+"""
+Constants for attendance module.
+"""
+
+# Collection names
+EMPLOYEES_COLLECTION = "scm_employees"
+
+# Error messages
+ERROR_DUPLICATE_CHECKIN = "Already checked in today"
+ERROR_GPS_DISABLED = "GPS tracking is disabled for this employee"
+ERROR_LOCATION_REQUIRED = "Location coordinates are required"
+ERROR_EMPLOYEE_NOT_FOUND = "Employee not found"
+ERROR_INVALID_COORDINATES = "Invalid GPS coordinates"
+
+# Success messages
+SUCCESS_CHECKIN = "Check-in successful"

app/tracker/attendance/models.py

@@ -0,0 +1,48 @@
+"""
+SQLAlchemy models for attendance tracking.
+"""
+from sqlalchemy import Column, String, Integer, Float, Date, BigInteger, TIMESTAMP, Index
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.sql import func
+import uuid
+
+from app.core.database import Base
+
+
+class ScmAttendance(Base):
+    """
+    Attendance tracking model.
+    One row per employee per day.
+    """
+    __tablename__ = "scm_attendance"
+    __table_args__ = (
+        Index('idx_scm_attendance_work_date', 'employee_id', 'work_date'),
+        Index('idx_scm_attendance_merchant', 'merchant_id', 'work_date'),
+        {'schema': 'trans'}
+    )
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    merchant_id = Column(UUID(as_uuid=True), nullable=False)
+    employee_id = Column(UUID(as_uuid=True), nullable=False)
+    work_date = Column(Date, nullable=False)
+    
+    # Check-in details
+    check_in_time = Column(BigInteger, nullable=True)  # Unix timestamp in milliseconds
+    check_in_lat = Column(Float, nullable=True)
+    check_in_lon = Column(Float, nullable=True)
+    check_in_geofence_id = Column(UUID(as_uuid=True), nullable=True)
+    
+    # Check-out details
+    check_out_time = Column(BigInteger, nullable=True)
+    check_out_lat = Column(Float, nullable=True)
+    check_out_lon = Column(Float, nullable=True)
+    
+    # Calculated fields
+    total_minutes = Column(Integer, nullable=True)
+    
+    # Timestamps
+    created_at = Column(TIMESTAMP, server_default=func.now(), nullable=False)
+    updated_at = Column(TIMESTAMP, server_default=func.now(), onupdate=func.now(), nullable=False)
+
+    def __repr__(self):
+        return f"<ScmAttendance(id={self.id}, employee_id={self.employee_id}, work_date={self.work_date})>"

app/tracker/attendance/router.py

@@ -0,0 +1,138 @@
+"""
+API router for attendance endpoints.
+"""
+from fastapi import APIRouter, Depends, HTTPException, status
+from app.core.logging import get_logger
+from app.dependencies.auth import get_current_user, TokenUser
+from app.nosql import get_database
+from app.tracker.attendance.service import AttendanceService, get_attendance_service
+from app.tracker.attendance.schemas import CheckInRequest, CheckInResponse, ErrorResponse
+
+logger = get_logger(__name__)
+
+router = APIRouter(prefix="/attendance", tags=["Attendance"])
+
+
+@router.post(
+    "/check-in",
+    response_model=CheckInResponse,
+    status_code=status.HTTP_201_CREATED,
+    responses={
+        201: {"description": "Check-in successful"},
+        400: {"model": ErrorResponse, "description": "Bad request - duplicate check-in or GPS disabled"},
+        401: {"description": "Unauthorized"},
+        422: {"description": "Validation error"},
+        500: {"model": ErrorResponse, "description": "Internal server error"}
+    },
+    summary="Employee Check-In",
+    description="""
+    Mark the start of an employee's working day.
+    
+    **Rules:**
+    - Can check-in only once per day
+    - Location coordinates are mandatory
+    - GPS tracking must be enabled for the employee
+    - Optional location_id if inside a geofence
+    
+    **Edge Cases:**
+    - Duplicate check-in → 400 error
+    - GPS disabled → 400 error (checked from MongoDB: scm_employees.location_settings.location_tracking_consent)
+    
+    **Data Storage:**
+    - Stores timestamp, coordinates, and geofence match (if any) in PostgreSQL
+    - Table: trans.scm_attendance
+    """
+)
+async def check_in(
+    payload: CheckInRequest,
+    current_user: TokenUser = Depends(get_current_user)
+) -> CheckInResponse:
+    """
+    Create a check-in record for the authenticated employee.
+    
+    Args:
+        payload: Check-in request with timestamp, latitude, longitude, and optional location_id
+        current_user: Authenticated user from JWT token
+        
+    Returns:
+        CheckInResponse with success status and attendance record ID
+        
+    Raises:
+        HTTPException 400: If duplicate check-in or GPS disabled
+        HTTPException 500: If internal error occurs
+    """
+    try:
+        # Get MongoDB database
+        mongo_db = get_database()
+        
+        # Create service instance
+        service = get_attendance_service(mongo_db)
+        
+        # Create check-in
+        result = await service.create_checkin(
+            employee_id=current_user.user_id,
+            merchant_id=current_user.merchant_id,
+            payload=payload
+        )
+        
+        logger.info(
+            "Check-in successful",
+            extra={
+                "employee_id": current_user.user_id,
+                "merchant_id": current_user.merchant_id,
+                "attendance_id": result.id
+            }
+        )
+        
+        return result
+        
+    except ValueError as e:
+        # Business logic errors (duplicate check-in, GPS disabled)
+        error_message = str(e)
+        logger.warning(
+            f"Check-in validation failed: {error_message}",
+            extra={
+                "employee_id": current_user.user_id,
+                "error": error_message
+            }
+        )
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "success": False,
+                "error": error_message,
+                "detail": error_message
+            }
+        )
+    except Exception as e:
+        # Unexpected errors
+        logger.error(
+            "Check-in failed with unexpected error",
+            extra={
+                "employee_id": current_user.user_id,
+                "error": str(e)
+            },
+            exc_info=e
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail={
+                "success": False,
+                "error": "Internal server error",
+                "detail": "An unexpected error occurred during check-in"
+            }
+        )
+
+
+@router.get(
+    "/health",
+    summary="Attendance Module Health Check",
+    description="Check if the attendance module is operational"
+)
+async def attendance_health():
+    """Health check endpoint for attendance module"""
+    return {
+        "status": "healthy",
+        "module": "attendance",
+        "version": "1.0.0"
+    }

app/tracker/attendance/schemas.py

@@ -0,0 +1,88 @@
+"""
+Pydantic schemas for attendance module.
+"""
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator
+from datetime import datetime
+
+
+class CheckInRequest(BaseModel):
+    """Request schema for check-in"""
+    timestamp: int = Field(..., description="Unix timestamp in milliseconds")
+    latitude: float = Field(..., description="GPS latitude", ge=-90, le=90)
+    longitude: float = Field(..., description="GPS longitude", ge=-180, le=180)
+    location_id: Optional[str] = Field(None, description="Geofence location ID if inside a geofence")
+    
+    @field_validator('timestamp')
+    @classmethod
+    def validate_timestamp(cls, v):
+        """Validate timestamp is reasonable"""
+        if v <= 0:
+            raise ValueError("Timestamp must be positive")
+        # Check if timestamp is not too far in the past or future (within 24 hours)
+        now_ms = int(datetime.now().timestamp() * 1000)
+        diff_hours = abs(now_ms - v) / (1000 * 60 * 60)
+        if diff_hours > 24:
+            raise ValueError("Timestamp is too far from current time")
+        return v
+    
+    @field_validator('latitude')
+    @classmethod
+    def validate_latitude(cls, v):
+        """Validate latitude range"""
+        if not -90 <= v <= 90:
+            raise ValueError("Latitude must be between -90 and 90")
+        return v
+    
+    @field_validator('longitude')
+    @classmethod
+    def validate_longitude(cls, v):
+        """Validate longitude range"""
+        if not -180 <= v <= 180:
+            raise ValueError("Longitude must be between -180 and 180")
+        return v
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "timestamp": 1708156800000,
+                "latitude": 19.0760,
+                "longitude": 72.8777,
+                "location_id": "loc_mumbai_office_001"
+            }
+        }
+    }
+
+
+class CheckInResponse(BaseModel):
+    """Response schema for check-in"""
+    success: bool = Field(..., description="Whether check-in was successful")
+    id: str = Field(..., description="Attendance record ID")
+    message: Optional[str] = Field(None, description="Success or error message")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "success": True,
+                "id": "550e8400-e29b-41d4-a716-446655440000",
+                "message": "Check-in successful"
+            }
+        }
+    }
+
+
+class ErrorResponse(BaseModel):
+    """Error response schema"""
+    success: bool = Field(False, description="Always false for errors")
+    error: str = Field(..., description="Error message")
+    detail: Optional[str] = Field(None, description="Detailed error information")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "success": False,
+                "error": "Already checked in today",
+                "detail": "You have already checked in for today"
+            }
+        }
+    }

app/tracker/attendance/service.py

@@ -0,0 +1,248 @@
+"""
+Service layer for attendance operations.
+Handles business logic for check-in/check-out.
+"""
+from typing import Optional, Dict, Any
+from datetime import datetime, date
+import uuid
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from app.core.logging import get_logger
+from app.postgres import get_postgres_connection, release_postgres_connection
+from app.tracker.attendance.schemas import CheckInRequest, CheckInResponse
+from app.tracker.attendance.constants import (
+    EMPLOYEES_COLLECTION,
+    ERROR_DUPLICATE_CHECKIN,
+    ERROR_GPS_DISABLED,
+    ERROR_EMPLOYEE_NOT_FOUND,
+    SUCCESS_CHECKIN
+)
+
+logger = get_logger(__name__)
+
+
+class AttendanceService:
+    """Service for attendance operations"""
+    
+    def __init__(self, mongo_db: AsyncIOMotorDatabase):
+        self.mongo_db = mongo_db
+        self.employees_collection = mongo_db[EMPLOYEES_COLLECTION]
+    
+    async def check_location_tracking_consent(self, employee_id: str) -> bool:
+        """
+        Check if employee has location tracking enabled.
+        
+        Args:
+            employee_id: Employee UUID
+            
+        Returns:
+            True if location tracking is enabled, False otherwise
+            
+        Raises:
+            ValueError: If employee not found or validation fails
+        """
+        try:
+            employee = await self.employees_collection.find_one(
+                {"user_id": employee_id},
+                {"location_settings.location_tracking_consent": 1}
+            )
+            
+            if not employee:
+                logger.warning(f"Employee not found: {employee_id}")
+                raise ValueError(ERROR_EMPLOYEE_NOT_FOUND)
+            
+            # Check location_settings.location_tracking_consent
+            location_settings = employee.get("location_settings", {})
+            consent = location_settings.get("location_tracking_consent", False)
+            
+            logger.info(f"Location tracking consent for {employee_id}: {consent}")
+            return consent
+            
+        except ValueError:
+            # Re-raise ValueError (employee not found)
+            raise
+        except Exception as e:
+            logger.error(f"Error checking location tracking consent: {e}", exc_info=e)
+            raise
+    
+    async def check_duplicate_checkin(
+        self, 
+        employee_id: str, 
+        work_date: date
+    ) -> bool:
+        """
+        Check if employee has already checked in today.
+        
+        Args:
+            employee_id: Employee UUID (as string)
+            work_date: Date to check
+            
+        Returns:
+            True if already checked in, False otherwise
+        """
+        conn = None
+        try:
+            conn = await get_postgres_connection()
+            
+            query = """
+                SELECT id FROM trans.scm_attendance
+                WHERE employee_id = $1::uuid AND work_date = $2
+            """
+            
+            result = await conn.fetchval(query, employee_id, work_date)
+            
+            return result is not None
+            
+        except Exception as e:
+            logger.error(f"Error checking duplicate check-in: {e}", exc_info=e)
+            raise
+        finally:
+            if conn:
+                await release_postgres_connection(conn)
+    
+    async def create_checkin(
+        self,
+        employee_id: str,
+        merchant_id: str,
+        payload: CheckInRequest
+    ) -> CheckInResponse:
+        """
+        Create a check-in record.
+        
+        Args:
+            employee_id: Employee UUID
+            merchant_id: Merchant UUID
+            payload: Check-in request data
+            
+        Returns:
+            CheckInResponse with attendance record ID
+            
+        Raises:
+            ValueError: If validation fails
+        """
+        # Convert timestamp to date
+        work_date = datetime.fromtimestamp(payload.timestamp / 1000).date()
+        
+        # 1. Check location tracking consent
+        has_consent = await self.check_location_tracking_consent(employee_id)
+        if not has_consent:
+            logger.warning(f"GPS disabled for employee {employee_id}")
+            raise ValueError(ERROR_GPS_DISABLED)
+        
+        # 2. Check for duplicate check-in
+        already_checked_in = await self.check_duplicate_checkin(employee_id, work_date)
+        if already_checked_in:
+            logger.warning(f"Duplicate check-in attempt for employee {employee_id} on {work_date}")
+            raise ValueError(ERROR_DUPLICATE_CHECKIN)
+        
+        # 3. Create attendance record
+        conn = None
+        try:
+            conn = await get_postgres_connection()
+            
+            attendance_id = uuid.uuid4()
+            
+            query = """
+                INSERT INTO trans.scm_attendance (
+                    id,
+                    merchant_id,
+                    employee_id,
+                    work_date,
+                    check_in_time,
+                    check_in_lat,
+                    check_in_lon,
+                    check_in_geofence_id,
+                    created_at,
+                    updated_at
+                ) VALUES ($1, $2::uuid, $3::uuid, $4, $5, $6, $7, $8::uuid, NOW(), NOW())
+                RETURNING id
+            """
+            
+            result = await conn.fetchval(
+                query,
+                attendance_id,
+                merchant_id,
+                employee_id,
+                work_date,
+                payload.timestamp,
+                payload.latitude,
+                payload.longitude,
+                payload.location_id
+            )
+            
+            logger.info(
+                f"Check-in created successfully",
+                extra={
+                    "attendance_id": str(result),
+                    "employee_id": employee_id,
+                    "merchant_id": merchant_id,
+                    "work_date": str(work_date),
+                    "geofence_id": payload.location_id if payload.location_id else None
+                }
+            )
+            
+            return CheckInResponse(
+                success=True,
+                id=str(result),
+                message=SUCCESS_CHECKIN
+            )
+            
+        except Exception as e:
+            logger.error(f"Error creating check-in: {e}", exc_info=e)
+            raise
+        finally:
+            if conn:
+                await release_postgres_connection(conn)
+    
+    async def get_attendance_by_id(self, attendance_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get attendance record by ID.
+        
+        Args:
+            attendance_id: Attendance UUID (as string)
+            
+        Returns:
+            Attendance record or None
+        """
+        conn = None
+        try:
+            conn = await get_postgres_connection()
+            
+            query = """
+                SELECT 
+                    id,
+                    merchant_id,
+                    employee_id,
+                    work_date,
+                    check_in_time,
+                    check_in_lat,
+                    check_in_lon,
+                    check_in_geofence_id,
+                    check_out_time,
+                    check_out_lat,
+                    check_out_lon,
+                    total_minutes,
+                    created_at,
+                    updated_at
+                FROM trans.scm_attendance
+                WHERE id = $1::uuid
+            """
+            
+            row = await conn.fetchrow(query, attendance_id)
+            
+            if not row:
+                return None
+            
+            return dict(row)
+            
+        except Exception as e:
+            logger.error(f"Error fetching attendance: {e}", exc_info=e)
+            raise
+        finally:
+            if conn:
+                await release_postgres_connection(conn)
+
+
+def get_attendance_service(mongo_db: AsyncIOMotorDatabase) -> AttendanceService:
+    """Factory function to create AttendanceService instance"""
+    return AttendanceService(mongo_db)

migrate_attendance.py

@@ -0,0 +1,156 @@
+"""
+Migration script to create attendance table and indexes.
+Run this script to set up the database schema for attendance tracking.
+"""
+import asyncio
+import asyncpg
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+
+async def run_migration():
+    """Create attendance table and indexes"""
+    
+    # Get database connection details
+    db_host = os.getenv("DB_HOST", "localhost")
+    db_port = int(os.getenv("DB_PORT", "5432"))
+    db_name = os.getenv("DB_NAME", "cuatrolabs")
+    db_user = os.getenv("DB_USER", "postgres")
+    db_password = os.getenv("DB_PASSWORD", "")
+    
+    print("=" * 80)
+    print("ATTENDANCE TABLE MIGRATION")
+    print("=" * 80)
+    print(f"Host: {db_host}")
+    print(f"Port: {db_port}")
+    print(f"Database: {db_name}")
+    print(f"User: {db_user}")
+    print("=" * 80)
+    
+    try:
+        # Connect to database
+        print("\n[1/4] Connecting to PostgreSQL...")
+        conn = await asyncpg.connect(
+            host=db_host,
+            port=db_port,
+            database=db_name,
+            user=db_user,
+            password=db_password
+        )
+        print("✅ Connected successfully")
+        
+        # Create trans schema
+        print("\n[2/4] Creating trans schema...")
+        await conn.execute("CREATE SCHEMA IF NOT EXISTS trans")
+        print("✅ Schema 'trans' created/verified")
+        
+        # Create attendance table
+        print("\n[3/4] Creating scm_attendance table...")
+        create_table_sql = """
+            CREATE TABLE IF NOT EXISTS trans.scm_attendance (
+                id UUID PRIMARY KEY,
+                merchant_id UUID NOT NULL,
+                employee_id UUID NOT NULL,
+                work_date DATE NOT NULL,
+                check_in_time BIGINT,
+                check_in_lat DOUBLE PRECISION,
+                check_in_lon DOUBLE PRECISION,
+                check_in_geofence_id UUID,
+                check_out_time BIGINT,
+                check_out_lat DOUBLE PRECISION,
+                check_out_lon DOUBLE PRECISION,
+                total_minutes INTEGER,
+                created_at TIMESTAMP DEFAULT now(),
+                updated_at TIMESTAMP DEFAULT now(),
+                UNIQUE (employee_id, work_date)
+            )
+        """
+        await conn.execute(create_table_sql)
+        print("✅ Table 'trans.scm_attendance' created/verified")
+        
+        # Create indexes
+        print("\n[4/4] Creating indexes...")
+        
+        # Index for employee + work_date lookups
+        index_sql = """
+            CREATE INDEX IF NOT EXISTS idx_scm_attendance_work_date
+            ON trans.scm_attendance (employee_id, work_date)
+        """
+        await conn.execute(index_sql)
+        print("✅ Index 'idx_scm_attendance_work_date' created")
+        
+        # Index for merchant + work_date lookups
+        index_merchant_sql = """
+            CREATE INDEX IF NOT EXISTS idx_scm_attendance_merchant
+            ON trans.scm_attendance (merchant_id, work_date)
+        """
+        await conn.execute(index_merchant_sql)
+        print("✅ Index 'idx_scm_attendance_merchant' created")
+        
+        # Verify table structure
+        print("\n[VERIFICATION] Checking table structure...")
+        columns = await conn.fetch("""
+            SELECT column_name, data_type, is_nullable
+            FROM information_schema.columns
+            WHERE table_schema = 'trans' 
+            AND table_name = 'scm_attendance'
+            ORDER BY ordinal_position
+        """)
+        
+        print("\nTable Structure:")
+        print("-" * 80)
+        for col in columns:
+            nullable = "NULL" if col['is_nullable'] == 'YES' else "NOT NULL"
+            print(f"  {col['column_name']:<25} {col['data_type']:<20} {nullable}")
+        print("-" * 80)
+        
+        # Check constraints
+        constraints = await conn.fetch("""
+            SELECT constraint_name, constraint_type
+            FROM information_schema.table_constraints
+            WHERE table_schema = 'trans' 
+            AND table_name = 'scm_attendance'
+        """)
+        
+        print("\nConstraints:")
+        print("-" * 80)
+        for constraint in constraints:
+            print(f"  {constraint['constraint_name']:<40} {constraint['constraint_type']}")
+        print("-" * 80)
+        
+        # Check indexes
+        indexes = await conn.fetch("""
+            SELECT indexname, indexdef
+            FROM pg_indexes
+            WHERE schemaname = 'trans' 
+            AND tablename = 'scm_attendance'
+        """)
+        
+        print("\nIndexes:")
+        print("-" * 80)
+        for index in indexes:
+            print(f"  {index['indexname']}")
+        print("-" * 80)
+        
+        # Close connection
+        await conn.close()
+        
+        print("\n" + "=" * 80)
+        print("✅ MIGRATION COMPLETED SUCCESSFULLY")
+        print("=" * 80)
+        print("\nNext steps:")
+        print("1. Start the Tracker microservice")
+        print("2. Test the check-in endpoint: POST /api/v1/attendance/check-in")
+        print("3. Check the API documentation: http://localhost:8003/docs")
+        print("=" * 80)
+        
+    except Exception as e:
+        print(f"\n❌ Migration failed: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    asyncio.run(run_migration())

migrate_attendance_fix_ids.py

@@ -0,0 +1,148 @@
+"""
+Migration script to change UUID columns to VARCHAR to support custom ID formats.
+This allows the attendance table to work with custom user IDs like 'usr_xxx' instead of UUIDs.
+"""
+import asyncio
+import asyncpg
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+
+async def run_migration():
+    """Alter attendance table to use VARCHAR for ID columns"""
+    
+    # Get database connection details
+    db_host = os.getenv("DB_HOST", "localhost")
+    db_port = int(os.getenv("DB_PORT", "5432"))
+    db_name = os.getenv("DB_NAME", "cuatrolabs")
+    db_user = os.getenv("DB_USER", "postgres")
+    db_password = os.getenv("DB_PASSWORD", "")
+    
+    print("=" * 80)
+    print("ATTENDANCE TABLE ID FIX MIGRATION")
+    print("=" * 80)
+    print(f"Host: {db_host}")
+    print(f"Port: {db_port}")
+    print(f"Database: {db_name}")
+    print(f"User: {db_user}")
+    print("=" * 80)
+    
+    try:
+        # Connect to database
+        print("\n[1/5] Connecting to PostgreSQL...")
+        conn = await asyncpg.connect(
+            host=db_host,
+            port=db_port,
+            database=db_name,
+            user=db_user,
+            password=db_password
+        )
+        print("✅ Connected successfully")
+        
+        # Check if table exists
+        print("\n[2/5] Checking if table exists...")
+        table_exists = await conn.fetchval("""
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables 
+                WHERE table_schema = 'trans' 
+                AND table_name = 'scm_attendance'
+            )
+        """)
+        
+        if not table_exists:
+            print("❌ Table trans.scm_attendance does not exist. Run migrate_attendance.py first.")
+            await conn.close()
+            return
+        
+        print("✅ Table exists")
+        
+        # Drop and recreate table with VARCHAR columns
+        print("\n[3/5] Dropping existing table...")
+        await conn.execute("DROP TABLE IF EXISTS trans.scm_attendance CASCADE")
+        print("✅ Table dropped")
+        
+        print("\n[4/5] Creating table with VARCHAR ID columns...")
+        create_table_sql = """
+            CREATE TABLE trans.scm_attendance (
+                id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+                merchant_id VARCHAR(100) NOT NULL,
+                employee_id VARCHAR(100) NOT NULL,
+                work_date DATE NOT NULL,
+                check_in_time BIGINT,
+                check_in_lat DOUBLE PRECISION,
+                check_in_lon DOUBLE PRECISION,
+                check_in_geofence_id VARCHAR(100),
+                check_out_time BIGINT,
+                check_out_lat DOUBLE PRECISION,
+                check_out_lon DOUBLE PRECISION,
+                total_minutes INTEGER,
+                created_at TIMESTAMP DEFAULT now(),
+                updated_at TIMESTAMP DEFAULT now(),
+                UNIQUE (employee_id, work_date)
+            )
+        """
+        await conn.execute(create_table_sql)
+        print("✅ Table created with VARCHAR ID columns")
+        
+        # Create indexes
+        print("\n[5/5] Creating indexes...")
+        
+        # Index for employee + work_date lookups
+        await conn.execute("""
+            CREATE INDEX idx_scm_attendance_work_date
+            ON trans.scm_attendance (employee_id, work_date)
+        """)
+        print("✅ Index 'idx_scm_attendance_work_date' created")
+        
+        # Index for merchant + work_date lookups
+        await conn.execute("""
+            CREATE INDEX idx_scm_attendance_merchant
+            ON trans.scm_attendance (merchant_id, work_date)
+        """)
+        print("✅ Index 'idx_scm_attendance_merchant' created")
+        
+        # Verify table structure
+        print("\n[VERIFICATION] Checking table structure...")
+        columns = await conn.fetch("""
+            SELECT column_name, data_type, character_maximum_length, is_nullable
+            FROM information_schema.columns
+            WHERE table_schema = 'trans' 
+            AND table_name = 'scm_attendance'
+            ORDER BY ordinal_position
+        """)
+        
+        print("\nTable Structure:")
+        print("-" * 80)
+        for col in columns:
+            nullable = "NULL" if col['is_nullable'] == 'YES' else "NOT NULL"
+            data_type = col['data_type']
+            if col['character_maximum_length']:
+                data_type += f"({col['character_maximum_length']})"
+            print(f"  {col['column_name']:<25} {data_type:<20} {nullable}")
+        print("-" * 80)
+        
+        # Close connection
+        await conn.close()
+        
+        print("\n" + "=" * 80)
+        print("✅ MIGRATION COMPLETED SUCCESSFULLY")
+        print("=" * 80)
+        print("\nChanges:")
+        print("  - merchant_id: UUID → VARCHAR(100)")
+        print("  - employee_id: UUID → VARCHAR(100)")
+        print("  - check_in_geofence_id: UUID → VARCHAR(100)")
+        print("\nThis allows custom ID formats like 'usr_xxx', 'mkt_xxx', etc.")
+        print("=" * 80)
+        
+    except Exception as e:
+        print(f"\n❌ Migration failed: {e}")
+        import traceback
+        traceback.print_exc()
+        raise
+
+
+if __name__ == "__main__":
+    asyncio.run(run_migration())

migrate_attendance_revert_to_uuid.py

@@ -0,0 +1,127 @@
+"""
+Migration script to revert ID columns back to UUID type.
+"""
+import asyncio
+import asyncpg
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+
+async def run_migration():
+    """Revert attendance table to use UUID for ID columns"""
+    
+    # Get database connection details
+    db_host = os.getenv("DB_HOST", "localhost")
+    db_port = int(os.getenv("DB_PORT", "5432"))
+    db_name = os.getenv("DB_NAME", "cuatrolabs")
+    db_user = os.getenv("DB_USER", "postgres")
+    db_password = os.getenv("DB_PASSWORD", "")
+    
+    print("=" * 80)
+    print("ATTENDANCE TABLE REVERT TO UUID MIGRATION")
+    print("=" * 80)
+    print(f"Host: {db_host}")
+    print(f"Port: {db_port}")
+    print(f"Database: {db_name}")
+    print(f"User: {db_user}")
+    print("=" * 80)
+    
+    try:
+        # Connect to database
+        print("\n[1/4] Connecting to PostgreSQL...")
+        conn = await asyncpg.connect(
+            host=db_host,
+            port=db_port,
+            database=db_name,
+            user=db_user,
+            password=db_password
+        )
+        print("✅ Connected successfully")
+        
+        # Drop and recreate table with UUID columns
+        print("\n[2/4] Dropping existing table...")
+        await conn.execute("DROP TABLE IF EXISTS trans.scm_attendance CASCADE")
+        print("✅ Table dropped")
+        
+        print("\n[3/4] Creating table with UUID columns...")
+        create_table_sql = """
+            CREATE TABLE trans.scm_attendance (
+                id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+                merchant_id UUID NOT NULL,
+                employee_id UUID NOT NULL,
+                work_date DATE NOT NULL,
+                check_in_time BIGINT,
+                check_in_lat DOUBLE PRECISION,
+                check_in_lon DOUBLE PRECISION,
+                check_in_geofence_id UUID,
+                check_out_time BIGINT,
+                check_out_lat DOUBLE PRECISION,
+                check_out_lon DOUBLE PRECISION,
+                total_minutes INTEGER,
+                created_at TIMESTAMP DEFAULT now(),
+                updated_at TIMESTAMP DEFAULT now(),
+                UNIQUE (employee_id, work_date)
+            )
+        """
+        await conn.execute(create_table_sql)
+        print("✅ Table created with UUID columns")
+        
+        # Create indexes
+        print("\n[4/4] Creating indexes...")
+        
+        # Index for employee + work_date lookups
+        await conn.execute("""
+            CREATE INDEX idx_scm_attendance_work_date
+            ON trans.scm_attendance (employee_id, work_date)
+        """)
+        print("✅ Index 'idx_scm_attendance_work_date' created")
+        
+        # Index for merchant + work_date lookups
+        await conn.execute("""
+            CREATE INDEX idx_scm_attendance_merchant
+            ON trans.scm_attendance (merchant_id, work_date)
+        """)
+        print("✅ Index 'idx_scm_attendance_merchant' created")
+        
+        # Verify table structure
+        print("\n[VERIFICATION] Checking table structure...")
+        columns = await conn.fetch("""
+            SELECT column_name, data_type, is_nullable
+            FROM information_schema.columns
+            WHERE table_schema = 'trans' 
+            AND table_name = 'scm_attendance'
+            ORDER BY ordinal_position
+        """)
+        
+        print("\nTable Structure:")
+        print("-" * 80)
+        for col in columns:
+            nullable = "NULL" if col['is_nullable'] == 'YES' else "NOT NULL"
+            print(f"  {col['column_name']:<25} {col['data_type']:<20} {nullable}")
+        print("-" * 80)
+        
+        # Close connection
+        await conn.close()
+        
+        print("\n" + "=" * 80)
+        print("✅ MIGRATION COMPLETED SUCCESSFULLY")
+        print("=" * 80)
+        print("\nReverted to UUID columns:")
+        print("  - merchant_id: UUID")
+        print("  - employee_id: UUID")
+        print("  - check_in_geofence_id: UUID")
+        print("\nMake sure JWT tokens contain valid UUID format for user_id and merchant_id")
+        print("=" * 80)
+        
+    except Exception as e:
+        print(f"\n❌ Migration failed: {e}")
+        import traceback
+        traceback.print_exc()
+        raise
+
+
+if __name__ == "__main__":
+    asyncio.run(run_migration())

requirements.txt

@@ -3,3 +3,20 @@ uvicorn[standard]==0.24.0
 pydantic>=2.12.5,<3.0.0
 pydantic-settings>=2.0.0
 python-dotenv==1.0.0
+python-multipart==0.0.6
+
+# Database
+motor==3.3.2
+pymongo==4.6.0
+asyncpg==0.31.0
+sqlalchemy[asyncio]==2.0.36
+
+# Authentication
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
+
+# Utilities
+insightfy-utils>=0.1.0
+
+# Logging
+python-json-logger==2.0.7

setup.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+echo "=========================================="
+echo "Tracker Microservice Setup"
+echo "=========================================="
+
+# Check Python version
+echo ""
+echo "Checking Python version..."
+python3 --version
+
+# Install insightfy-utils from wheel first
+echo ""
+echo "Installing insightfy-utils..."
+python3 -m pip install --user app/insightfy_utils-0.1.0-py3-none-any.whl
+
+# Install dependencies
+echo ""
+echo "Installing dependencies..."
+python3 -m pip install --user -r requirements.txt
+
+# Check if .env exists
+echo ""
+if [ -f ".env" ]; then
+    echo "✅ .env file exists"
+else
+    echo "⚠️  .env file not found. Creating from .env.example..."
+    cp .env.example .env
+    echo "✅ Created .env file. Please edit it with your credentials."
+fi
+
+# Run migration
+echo ""
+echo "Do you want to run the database migration now? (y/n)"
+read -r response
+if [[ "$response" =~ ^([yY][eE][sS]|[yY])$ ]]; then
+    echo "Running migration..."
+    python3 migrate_attendance.py
+else
+    echo "Skipping migration. Run 'python3 migrate_attendance.py' when ready."
+fi
+
+echo ""
+echo "=========================================="
+echo "✅ Setup Complete!"
+echo "=========================================="
+echo ""
+echo "Next steps:"
+echo "1. Edit .env file with your database credentials"
+echo "2. Run migration: python3 migrate_attendance.py"
+echo "3. Start service: python3 -m uvicorn app.main:app --host 0.0.0.0 --port 8003 --reload"
+echo "4. Or press F5 in VS Code to debug"
+echo ""
+echo "API Documentation: http://localhost:8003/docs"
+echo "=========================================="

test_checkin.py

@@ -0,0 +1,239 @@
+"""
+Test script for attendance check-in API.
+Generates a JWT token and tests the check-in endpoint.
+"""
+import requests
+import json
+from datetime import datetime, timedelta
+from jose import jwt
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Configuration
+BASE_URL = "http://localhost:8003"
+SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key-change-in-production")
+ALGORITHM = os.getenv("ALGORITHM", "HS256")
+
+
+def generate_test_token(
+    user_id: str = "550e8400-e29b-41d4-a716-446655440000",
+    username: str = "test.employee@example.com",
+    merchant_id: str = "660e8400-e29b-41d4-a716-446655440000",
+    role: str = "employee"
+) -> str:
+    """Generate a test JWT token"""
+    
+    payload = {
+        "sub": user_id,
+        "username": username,
+        "merchant_id": merchant_id,
+        "role": role,
+        "exp": datetime.utcnow() + timedelta(hours=8)
+    }
+    
+    token = jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
+    return token
+
+
+def test_health_check():
+    """Test health check endpoint"""
+    print("\n" + "=" * 80)
+    print("TEST 1: Health Check")
+    print("=" * 80)
+    
+    response = requests.get(f"{BASE_URL}/health")
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {json.dumps(response.json(), indent=2)}")
+    
+    assert response.status_code == 200
+    print("✅ Health check passed")
+
+
+def test_attendance_health():
+    """Test attendance module health check"""
+    print("\n" + "=" * 80)
+    print("TEST 2: Attendance Module Health Check")
+    print("=" * 80)
+    
+    response = requests.get(f"{BASE_URL}/api/v1/attendance/health")
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {json.dumps(response.json(), indent=2)}")
+    
+    assert response.status_code == 200
+    print("✅ Attendance health check passed")
+
+
+def test_checkin_without_auth():
+    """Test check-in without authentication (should fail)"""
+    print("\n" + "=" * 80)
+    print("TEST 3: Check-in Without Authentication (Should Fail)")
+    print("=" * 80)
+    
+    payload = {
+        "timestamp": int(datetime.now().timestamp() * 1000),
+        "latitude": 19.0760,
+        "longitude": 72.8777,
+        "location_id": "loc_mumbai_office_001"
+    }
+    
+    response = requests.post(
+        f"{BASE_URL}/api/v1/attendance/check-in",
+        json=payload
+    )
+    
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {json.dumps(response.json(), indent=2)}")
+    
+    assert response.status_code == 403  # Forbidden without auth
+    print("✅ Correctly rejected unauthenticated request")
+
+
+def test_checkin_with_auth():
+    """Test check-in with authentication"""
+    print("\n" + "=" * 80)
+    print("TEST 4: Check-in With Authentication")
+    print("=" * 80)
+    
+    # Generate token
+    token = generate_test_token()
+    print(f"Generated JWT Token: {token[:50]}...")
+    
+    # Prepare payload
+    payload = {
+        "timestamp": int(datetime.now().timestamp() * 1000),
+        "latitude": 19.0760,
+        "longitude": 72.8777,
+        "location_id": "loc_mumbai_office_001"
+    }
+    
+    print(f"\nRequest Payload:")
+    print(json.dumps(payload, indent=2))
+    
+    # Make request
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    response = requests.post(
+        f"{BASE_URL}/api/v1/attendance/check-in",
+        json=payload,
+        headers=headers
+    )
+    
+    print(f"\nStatus Code: {response.status_code}")
+    print(f"Response: {json.dumps(response.json(), indent=2)}")
+    
+    if response.status_code == 201:
+        print("✅ Check-in successful")
+    elif response.status_code == 400:
+        error_detail = response.json().get("detail", {})
+        if "Already checked in" in str(error_detail):
+            print("⚠️  Already checked in today (expected if running multiple times)")
+        elif "GPS" in str(error_detail):
+            print("⚠️  GPS tracking disabled for this employee")
+            print("   To fix: Update MongoDB scm_employees collection")
+            print("   Set location_settings.location_tracking_consent = true")
+        else:
+            print(f"❌ Check-in failed: {error_detail}")
+    else:
+        print(f"❌ Unexpected status code: {response.status_code}")
+
+
+def test_checkin_invalid_coordinates():
+    """Test check-in with invalid coordinates"""
+    print("\n" + "=" * 80)
+    print("TEST 5: Check-in With Invalid Coordinates (Should Fail)")
+    print("=" * 80)
+    
+    token = generate_test_token()
+    
+    payload = {
+        "timestamp": int(datetime.now().timestamp() * 1000),
+        "latitude": 999.0,  # Invalid latitude
+        "longitude": 72.8777
+    }
+    
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    response = requests.post(
+        f"{BASE_URL}/api/v1/attendance/check-in",
+        json=payload,
+        headers=headers
+    )
+    
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {json.dumps(response.json(), indent=2)}")
+    
+    assert response.status_code == 422  # Validation error
+    print("✅ Correctly rejected invalid coordinates")
+
+
+def test_checkin_missing_fields():
+    """Test check-in with missing required fields"""
+    print("\n" + "=" * 80)
+    print("TEST 6: Check-in With Missing Fields (Should Fail)")
+    print("=" * 80)
+    
+    token = generate_test_token()
+    
+    payload = {
+        "timestamp": int(datetime.now().timestamp() * 1000),
+        # Missing latitude and longitude
+    }
+    
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    response = requests.post(
+        f"{BASE_URL}/api/v1/attendance/check-in",
+        json=payload,
+        headers=headers
+    )
+    
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {json.dumps(response.json(), indent=2)}")
+    
+    assert response.status_code == 422  # Validation error
+    print("✅ Correctly rejected request with missing fields")
+
+
+def main():
+    """Run all tests"""
+    print("\n" + "=" * 80)
+    print("ATTENDANCE CHECK-IN API TEST SUITE")
+    print("=" * 80)
+    print(f"Base URL: {BASE_URL}")
+    print(f"Time: {datetime.now().isoformat()}")
+    print("=" * 80)
+    
+    try:
+        test_health_check()
+        test_attendance_health()
+        test_checkin_without_auth()
+        test_checkin_invalid_coordinates()
+        test_checkin_missing_fields()
+        test_checkin_with_auth()  # Run this last as it may succeed
+        
+        print("\n" + "=" * 80)
+        print("✅ ALL TESTS COMPLETED")
+        print("=" * 80)
+        
+    except requests.exceptions.ConnectionError:
+        print("\n❌ ERROR: Could not connect to the server")
+        print(f"   Make sure the service is running at {BASE_URL}")
+        print("   Run: uvicorn app.main:app --host 0.0.0.0 --port 8003")
+    except Exception as e:
+        print(f"\n❌ ERROR: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    main()

test_request.json

@@ -0,0 +1,6 @@
+{
+  "timestamp": 1771332328203,
+  "latitude": 13.0827,
+  "longitude": 80.2707,
+  "location_id": null
+}