ebook-extension/ebook_backend_admin_panel/admin-backend/routes/auth.py

from fastapi import APIRouter, Depends, HTTPException, Form, status, Request, UploadFile, File
from fastapi.responses import JSONResponse, HTMLResponse, RedirectResponse
from sqlalchemy.orm import Session
from models.user import AdminUser
from utils.auth import get_db, hash_password, verify_password
from fastapi.templating import Jinja2Templates
from utils.template_loader import templates
from models.coupon import Coupon
from utils.coupon_utils import generate_coupon
from datetime import datetime
import pytz
from utils.timezone_utils import format_cest_datetime
from schemas import AdminLogin, CodeItem, CouponUpload
from fastapi.responses import StreamingResponse
import os

router = APIRouter()


@router.get("/login", response_class=HTMLResponse)
async def login_page(request: Request):
    """
    Render the admin login page.
    Args:
        request (Request): The incoming request object.
    Returns:
        HTMLResponse: Rendered login page.
    """
    # return templates.TemplateResponse("admin_login.html", {"request": request})
    return templates.TemplateResponse(request, "admin_login.html", {"data": "something"})



@router.get("/", response_class=HTMLResponse)
def admin_panel(request: Request):
    """
    Render the admin dashboard if logged in.
    Args:
        request (Request): The incoming request object.
    Returns:
        HTMLResponse or RedirectResponse: Admin dashboard or redirect to login.
    """
    if not request.cookies.get("admin_logged_in"):
        return RedirectResponse(url="/login", status_code=status.HTTP_302_FOUND)
    # return templates.TemplateResponse("admin_dashboard.html", {"request": request})
    return templates.TemplateResponse(request, "admin_dashboard.html", {"data": "something"})



@router.post("/admin/login")
def login(data: AdminLogin, db: Session = Depends(get_db)):
    """
    Handle admin login and set authentication cookie.
    Args:
        data (AdminLogin): Login data with username and password.
        db (Session): Database session.
    Returns:
        JSONResponse: Login status.
    """
    user = db.query(AdminUser).filter_by(username=data.username).first()
    if not user or not verify_password(data.password, user.password_hash):
        raise HTTPException(status_code=401, detail="Invalid credentials")
    response = JSONResponse(content={"status": "success"})
    response.set_cookie("admin_logged_in", "true", httponly=True, samesite="strict")
    return response


@router.post("/admin/logout")
def logout():
    """
    Handle admin logout and clear the authentication cookie.
    Returns:
        JSONResponse: Logout status.
    """
    response = JSONResponse(content={"status": "success"})
    response.delete_cookie("admin_logged_in")
    return response

@router.post("/generate")
async def generate_code(mode: str = Form(...), count: int = Form(1), db: Session = Depends(get_db),
                        request: Request = None):
    """
        Generate coupon codes (single or bulk).
        Args:
            mode (str): 'single' or 'bulk'.
            count (int): Number of codes to generate (used for bulk).
            db (Session): Database session.
            request (Request): Incoming request for auth check.
        Returns:
            dict: Generated codes.
        """
    if not request.cookies.get("admin_logged_in"):
        raise HTTPException(status_code=401, detail="Unauthorized")

    new_codes = []
    if mode == "single":
        new_code = generate_coupon().upper()  # Convert to uppercase
        db_code = Coupon(code=new_code, usage_count=0)
        db.add(db_code)
        db.commit()
        return {"code": new_code}
    elif mode == "bulk":
        for _ in range(count):
            code = generate_coupon().upper()  # Convert to uppercase
            db_code = Coupon(code=code, usage_count=0)
            db.add(db_code)
            new_codes.append(code)
        db.commit()
        return {"codes": new_codes}
    else:
        raise HTTPException(status_code=400, detail="Invalid mode")


@router.get("/list")
async def list_codes(page: int = 1, limit: int = 20, db: Session = Depends(get_db)):
    """
       List paginated coupon codes sorted by usage count.
       Args:
           page (int): Page number.
           limit (int): Items per page.
           db (Session): Database session.
       Returns:
           dict: Paginated coupon data.
       """
    offset = (page - 1) * limit
    total_coupons = db.query(Coupon).count()
    coupons = db.query(Coupon).order_by(Coupon.usage_count.desc()).offset(offset).limit(limit).all()

    return {
        "codes": [{"code": c.code, "used_at": format_cest_datetime(c.used_at) if c.used_at else None, "usage_count": c.usage_count} for c in coupons],
        "total": total_coupons,
        "page": page,
        "limit": limit,
        "total_pages": (total_coupons + limit - 1) // limit
    }


@router.get("/search-codes")
def search_codes(query: str, db: Session = Depends(get_db)):
    """
        Search coupon codes by partial match (case-insensitive).
        Args:
            query (str): Search query.
            db (Session): Database session.
        Returns:
            list: Matching coupon codes.
        """
    # Search with case-insensitive matching
    codes = (
        db.query(Coupon)
        .filter(Coupon.code.ilike(f"%{query.upper()}%"))
        .all()
    )
    return [{"code": c.code, "used": c.usage_count, "usage_count": c.usage_count, "used_at": format_cest_datetime(c.used_at) if c.used_at else None} for c in codes]


@router.post("/use-code")
async def use_code(item: dict, db: Session = Depends(get_db)):
    """
     Mark a coupon code as used (only if not already used).
     Args:
         item (dict): Dictionary containing the code to mark as used.
         db (Session): Database session.
     Returns:
         dict: Updated code and timestamp.
     """
    code = item["code"].strip()
    coupon = db.query(Coupon).filter(Coupon.code.ilike(code)).first()
    if not coupon:
        raise HTTPException(status_code=404, detail="Invalid code")
    if coupon.usage_count >= 1:
        raise HTTPException(status_code=400, detail="Coupon already used")
    coupon.usage_count += 1
    coupon.used_at = datetime.now(pytz.timezone('Asia/Kolkata'))
    db.commit()
    return {"code": coupon.code, "used_at": format_cest_datetime(coupon.used_at)}


@router.get("/check-code/{code}")
async def check_code(code: str, db: Session = Depends(get_db)):
    """
       Check if a specific coupon code exists and its usage count.
       Args:
           code (str): Coupon code to check.
           db (Session): Database session.
       Returns:
           dict: Code and usage count.
       """
    # Use case-insensitive search to handle both cases
    coupon = db.query(Coupon).filter(Coupon.code.ilike(code.strip())).first()
    if not coupon:
        raise HTTPException(status_code=404, detail="Code not found")
    return {"code": coupon.code, "used": coupon.usage_count}


@router.post("/verify")
async def verify_coupon(coupon_req: dict, db: Session = Depends(get_db)):
    """
      Verify and mark a coupon as used if it exists and is unused.
      Args:
          coupon_req (dict): Dictionary with 'code' key.
          db (Session): Database session.
      Returns:
          dict: Success message and timestamp.
      """
    raw_code = coupon_req["code"]
    code = raw_code.strip()
    coupon = db.query(Coupon).filter(Coupon.code.ilike(code)).first()
    if not coupon:
        raise HTTPException(status_code=404, detail="Invalid coupon code")
    if coupon.usage_count >= 1:
        raise HTTPException(status_code=400, detail="Coupon already used")
    coupon.usage_count += 1
    coupon.used_at = datetime.now(pytz.timezone('Asia/Kolkata'))
    db.commit()
    return {"message": "Coupon verified", "used_at": format_cest_datetime(coupon.used_at)}


@router.post("/upload-codes")
async def upload_codes(upload_data: CouponUpload, db: Session = Depends(get_db), request: Request = None):
    """
    Upload multiple coupon codes from Excel data.
    Args:
        upload_data (CouponUpload): Pydantic model containing code list.
        db (Session): Database session.
        request (Request): Request object for auth check.
    Returns:
        dict: Upload summary (uploaded, skipped, total).
    """
    if not request.cookies.get("admin_logged_in"):
        raise HTTPException(status_code=401, detail="Unauthorized")

    uploaded = 0
    skipped = 0

    for coupon_data in upload_data.codes:
        try:
            # Normalize code to uppercase
            normalized_code = coupon_data.code.strip().upper()

            # Check if code already exists
            existing_coupon = db.query(Coupon).filter(Coupon.code == normalized_code).first()
            if existing_coupon:
                skipped += 1
                continue

            # Create new coupon with usage count from Excel
            new_coupon = Coupon(
                code=normalized_code,  # Store as uppercase
                usage_count=coupon_data.usage
            )
            db.add(new_coupon)
            uploaded += 1

        except Exception as e:
            print(f"Error inserting code {coupon_data.code}: {e}")
            skipped += 1

    try:
        db.commit()
    except Exception as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")

    return {
        "uploaded": uploaded,
        "skipped": skipped,
        "total": len(upload_data.codes)
    }


@router.post("/add-code")
def add_code(item: CodeItem, db: Session = Depends(get_db), request: Request = None):
    """
    Add a single coupon code manually.
    Args:
        item (CodeItem): Coupon data from request body.
        db (Session): Database session.
        request (Request): Request object for auth check.
    Returns:
        dict: Success message.
    """
    if not request.cookies.get("admin_logged_in"):
        raise HTTPException(status_code=401, detail="Unauthorized")

    # Normalize code to uppercase for consistency
    normalized_code = item.code.strip().upper()

    existing = db.query(Coupon).filter(Coupon.code == normalized_code).first()
    if existing:
        raise HTTPException(status_code=400, detail="Code already exists")

    new_coupon = Coupon(
        code=normalized_code,  # Store as uppercase
        usage_count=max(0, item.usage)
    )
    db.add(new_coupon)
    db.commit()
    return {"message": "Code added successfully"}


@router.delete("/delete-code/{code}")
def delete_code(code: str, db: Session = Depends(get_db), request: Request = None):
    """
    Delete a specific coupon code.
    Args:
        code (str): Coupon code to delete.
        db (Session): Database session.
        request (Request): Request object for auth check.
    Returns:
        dict: Success message.
    """
    if not request.cookies.get("admin_logged_in"):
        raise HTTPException(status_code=401, detail="Unauthorized")

    # Use case-insensitive search to handle both uppercase and lowercase codes
    coupon = db.query(Coupon).filter(Coupon.code.ilike(code.strip())).first()
    if not coupon:
        raise HTTPException(status_code=404, detail="Code not found")

    db.delete(coupon)
    db.commit()
    return {"message": "Code deleted successfully"}


# Translation file management
TRANSLATION_DIR = os.path.join(os.path.dirname(__file__), '..', 'translationfile')
TRANSLATION_DIR = os.path.abspath(TRANSLATION_DIR)
TRANSLATION_FILENAME = 'translation.xlsx'
TRANSLATION_PATH = os.path.join(TRANSLATION_DIR, TRANSLATION_FILENAME)


@router.post("/upload-translations")
async def upload_translation(file: UploadFile = File(...), request: Request = None):
    """
    Upload a new translation Excel file. Stores the file on disk and saves the original filename in metadata.
    Args:
        file (UploadFile): The uploaded Excel file.
        request (Request): Request object to check admin authentication.
    Returns:
        dict: Success message with original filename.
    """
    if not request.cookies.get("admin_logged_in"):
        raise HTTPException(status_code=401, detail="Unauthorized")

    # Create directory if it doesn't exist
    if not os.path.exists(TRANSLATION_DIR):
        os.makedirs(TRANSLATION_DIR, exist_ok=True)

    # Check if a translation file already exists
    if os.path.exists(TRANSLATION_PATH):
        raise HTTPException(status_code=400, detail="A translation file already exists. Please delete it first.")

    # Store the original filename in a metadata file
    original_filename = file.filename or "translation.xlsx"
    metadata_path = os.path.join(TRANSLATION_DIR, 'metadata.txt')

    try:
        # Read and save the uploaded file
        content = await file.read()
        with open(TRANSLATION_PATH, 'wb') as f:
            f.write(content)

        # Save the original filename to metadata file
        with open(metadata_path, 'w') as f:
            f.write(original_filename)

        return {"message": "Translation file uploaded successfully", "filename": original_filename}

    except Exception as e:
        # Clean up if there was an error
        if os.path.exists(TRANSLATION_PATH):
            os.remove(TRANSLATION_PATH)
        if os.path.exists(metadata_path):
            os.remove(metadata_path)
        raise HTTPException(status_code=500, detail=f"Upload failed: {str(e)}")


@router.delete("/delete-translation")
def delete_translation(request: Request = None):
    """
      Delete the uploaded translation file and its metadata.
      Args:
          request (Request): Request object to check admin authentication.
      Returns:
          dict: Success message if deletion was successful.
      """
    if not request.cookies.get("admin_logged_in"):
        raise HTTPException(status_code=401, detail="Unauthorized")

    metadata_path = os.path.join(TRANSLATION_DIR, 'metadata.txt')
    files_deleted = []

    # Delete the translation file
    if os.path.exists(TRANSLATION_PATH):
        os.remove(TRANSLATION_PATH)
        files_deleted.append("translation file")

    # Delete the metadata file
    if os.path.exists(metadata_path):
        os.remove(metadata_path)
        files_deleted.append("metadata")

    # Delete the translation directory if it exists and is empty
    if os.path.exists(TRANSLATION_DIR) and not os.listdir(TRANSLATION_DIR):
        os.rmdir(TRANSLATION_DIR)
        files_deleted.append("directory")

    if files_deleted:
        return {"message": f"Translation file deleted successfully"}
    else:
        raise HTTPException(status_code=404, detail="No translation file found")


@router.get("/download-translation")
def download_translation(request: Request = None):
    """
     Download the uploaded translation file with original filename.
     Args:
         request (Request): Request object to check admin authentication.
     Returns:
         StreamingResponse: Downloadable Excel file.
     """
    if not request.cookies.get("admin_logged_in"):
        raise HTTPException(status_code=401, detail="Unauthorized")

    if not os.path.exists(TRANSLATION_PATH):
        raise HTTPException(status_code=404, detail="No translation file found")

    # Get the original filename from metadata
    metadata_path = os.path.join(TRANSLATION_DIR, 'metadata.txt')
    original_filename = TRANSLATION_FILENAME  # Default filename

    if os.path.exists(metadata_path):
        try:
            with open(metadata_path, 'r') as f:
                stored_filename = f.read().strip()
                if stored_filename:
                    original_filename = stored_filename
        except Exception:
            # If we can't read metadata, use default filename
            pass

    # Return the file with proper headers
    def file_generator():
        with open(TRANSLATION_PATH, 'rb') as f:
            while True:
                chunk = f.read(8192)  # 8KB chunks
                if not chunk:
                    break
                yield chunk

    return StreamingResponse(
        file_generator(),
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition": f"attachment; filename=\"{original_filename}\""}
    )

@router.get("/translations/status")
def check_translation_file():
    """Check if translation file exists and return filename"""
    file_exists = os.path.exists(TRANSLATION_PATH)

    if not file_exists:
        return {"file_exists": False, "file_name": None}

    # Get the original filename from metadata
    metadata_path = os.path.join(TRANSLATION_DIR, 'metadata.txt')
    original_filename = TRANSLATION_FILENAME  # Default filename

    if os.path.exists(metadata_path):
        try:
            with open(metadata_path, 'r') as f:
                stored_filename = f.read().strip()
                if stored_filename:
                    original_filename = stored_filename
        except Exception:
            # If we can't read metadata, use default filename
            pass

    return {
        "file_exists": True,
        "file_name": original_filename
    }


@router.get("/translations/latest")
def get_latest_translation():
    """
    Legacy endpoint that returns the latest uploaded translation file.
    Returns:
        StreamingResponse: Downloadable Excel file.
    """
    if not os.path.exists(TRANSLATION_PATH):
        raise HTTPException(status_code=404, detail="No translation file found")

    # Get the original filename from metadata for consistency
    metadata_path = os.path.join(TRANSLATION_DIR, 'metadata.txt')
    original_filename = TRANSLATION_FILENAME  # Default filename

    if os.path.exists(metadata_path):
        try:
            with open(metadata_path, 'r') as f:
                stored_filename = f.read().strip()
                if stored_filename:
                    original_filename = stored_filename
        except Exception:
            pass

    return StreamingResponse(
        open(TRANSLATION_PATH, 'rb'),
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition": f"attachment; filename=\"{original_filename}\""}
    )