Update main.py

main.py

@@ -1,147 +1,147 @@
-from fastapi import FastAPI, Request, Form, Depends, HTTPException
-from fastapi.templating import Jinja2Templates
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import HTMLResponse, RedirectResponse
-from sqlalchemy import create_engine, Column, Integer, String, Boolean, DateTime, Text
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker, Session
-from datetime import datetime
-import re
-import os
-import bcrypt
-import random
-import string
-from typing import Optional
-
-# Define base URL (update for deployment)
-BASE_URL = "http://localhost:7860"
-
-# Create the FastAPI app
-app = FastAPI(title="Notepad App")
-
-# Set up templates and static files directories
-templates_dir = os.path.join(os.path.dirname(__file__), "templates")
-templates = Jinja2Templates(directory=templates_dir)
-
-# Create static directory if it doesn't exist
-static_dir = os.path.join(os.path.dirname(__file__), "static")
-os.makedirs(static_dir, exist_ok=True)
-app.mount("/static", StaticFiles(directory=static_dir), name="static")
-
-# Database setup
-DATABASE_URL = "sqlite:///./notepad.db"
-engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-Base = declarative_base()
-
-# Define the Note model (custom slug stored in "code")
-class Note(Base):
-    __tablename__ = "notes"
-    
-    id = Column(Integer, primary_key=True, index=True)
-    code = Column(String, unique=True, index=True)  # Custom slug
-    content = Column(Text)
-    is_private = Column(Boolean, default=False)
-    password = Column(String, nullable=True)
-    created_at = Column(DateTime, default=datetime.utcnow)
-
-# Create the database tables
-Base.metadata.create_all(bind=engine)
-
-# Dependency to get DB session
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-# Function to detect image URLs in text and convert them to HTML img tags
-def process_content(content):
-    image_pattern = r'(https?://\S+\.(?:jpg|jpeg|png|gif|webp|svg))'
-    processed_content = re.sub(
-        image_pattern,
-        r'<img src="\1" class="my-2 max-w-full h-auto rounded" alt="Image">',
-        content
-    )
-    processed_content = processed_content.replace('\n', '<br>')
-    return processed_content
-
-# Function to generate a random code for auto-generated slug (6-character)
-def generate_random_code(length=6):
-    characters = string.ascii_letters + string.digits
-    return ''.join(random.choice(characters) for _ in range(length))
-
-# GET /{slug}: Check for note; if exists, show it; otherwise, show creation form
-@app.get("/{slug}", response_class=HTMLResponse)
-async def custom_slug(request: Request, slug: str, db: Session = Depends(get_db)):
-    note = db.query(Note).filter(Note.code == slug).first()
-    if note:
-        if note.is_private:
-            return templates.TemplateResponse("password.html", {"request": request, "slug": slug})
-        processed_content = process_content(note.content)
-        return templates.TemplateResponse("view.html", {"request": request, "note": note, "content": processed_content})
-    else:
-        # No note exists for this slug; show creation form with slug pre-set.
-        return templates.TemplateResponse("index.html", {"request": request, "slug": slug})
-
-# POST /create: Create a note with the provided custom slug
-@app.post("/create", response_class=HTMLResponse)
-async def create_note(
-    request: Request,
-    slug: str = Form(...),
-    content: str = Form(...),
-    is_private: bool = Form(False),
-    password: Optional[str] = Form(None),
-    db: Session = Depends(get_db)
-):
-    # Check if slug already exists
-    if db.query(Note).filter(Note.code == slug).first():
-        raise HTTPException(status_code=400, detail="Slug already exists. Choose a different one.")
-    
-    hashed_password = None
-    if is_private and password:
-        hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
-    
-    new_note = Note(
-        code=slug,
-        content=content,
-        is_private=is_private,
-        password=hashed_password
-    )
-    db.add(new_note)
-    db.commit()
-    
-    return RedirectResponse(url=f"{BASE_URL}/{slug}", status_code=303)
-
-# POST /{slug}/verify: Verify password for private notes
-@app.post("/{slug}/verify", response_class=HTMLResponse)
-async def verify_password(
-    request: Request,
-    slug: str,
-    password: str = Form(...),
-    db: Session = Depends(get_db)
-):
-    note = db.query(Note).filter(Note.code == slug).first()
-    if not note:
-        raise HTTPException(status_code=404, detail="Note not found")
-    
-    if not note.is_private or not note.password:
-        return RedirectResponse(url=f"{BASE_URL}/{slug}", status_code=303)
-    
-    is_valid = bcrypt.checkpw(password.encode('utf-8'), note.password.encode('utf-8'))
-    if not is_valid:
-        return templates.TemplateResponse("password.html", {"request": request, "slug": slug, "error": "Invalid password", "error_effect": True})
-    
-    processed_content = process_content(note.content)
-    return templates.TemplateResponse("view.html", {"request": request, "note": note, "content": processed_content})
-
-# Landing page: If no slug provided, auto-generate one for the creation form
-@app.get("/", response_class=HTMLResponse)
-async def landing(request: Request):
-    random_slug = generate_random_code()
-    return templates.TemplateResponse("index.html", {"request": request, "slug": random_slug})
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)
+from fastapi import FastAPI, Request, Form, Depends, HTTPException
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, RedirectResponse
+from sqlalchemy import create_engine, Column, Integer, String, Boolean, DateTime, Text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, Session
+from datetime import datetime
+import re
+import os
+import bcrypt
+import random
+import string
+from typing import Optional
+
+# Define base URL (update for deployment)
+BASE_URL = "https://triflix-slugs.hf.space"
+
+# Create the FastAPI app
+app = FastAPI(title="Notepad App")
+
+# Set up templates and static files directories
+templates_dir = os.path.join(os.path.dirname(__file__), "templates")
+templates = Jinja2Templates(directory=templates_dir)
+
+# Create static directory if it doesn't exist
+static_dir = os.path.join(os.path.dirname(__file__), "static")
+os.makedirs(static_dir, exist_ok=True)
+app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+# Database setup
+DATABASE_URL = "sqlite:///./notepad.db"
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+# Define the Note model (custom slug stored in "code")
+class Note(Base):
+    __tablename__ = "notes"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    code = Column(String, unique=True, index=True)  # Custom slug
+    content = Column(Text)
+    is_private = Column(Boolean, default=False)
+    password = Column(String, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+# Create the database tables
+Base.metadata.create_all(bind=engine)
+
+# Dependency to get DB session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+# Function to detect image URLs in text and convert them to HTML img tags
+def process_content(content):
+    image_pattern = r'(https?://\S+\.(?:jpg|jpeg|png|gif|webp|svg))'
+    processed_content = re.sub(
+        image_pattern,
+        r'<img src="\1" class="my-2 max-w-full h-auto rounded" alt="Image">',
+        content
+    )
+    processed_content = processed_content.replace('\n', '<br>')
+    return processed_content
+
+# Function to generate a random code for auto-generated slug (6-character)
+def generate_random_code(length=6):
+    characters = string.ascii_letters + string.digits
+    return ''.join(random.choice(characters) for _ in range(length))
+
+# GET /{slug}: Check for note; if exists, show it; otherwise, show creation form
+@app.get("/{slug}", response_class=HTMLResponse)
+async def custom_slug(request: Request, slug: str, db: Session = Depends(get_db)):
+    note = db.query(Note).filter(Note.code == slug).first()
+    if note:
+        if note.is_private:
+            return templates.TemplateResponse("password.html", {"request": request, "slug": slug})
+        processed_content = process_content(note.content)
+        return templates.TemplateResponse("view.html", {"request": request, "note": note, "content": processed_content})
+    else:
+        # No note exists for this slug; show creation form with slug pre-set.
+        return templates.TemplateResponse("index.html", {"request": request, "slug": slug})
+
+# POST /create: Create a note with the provided custom slug
+@app.post("/create", response_class=HTMLResponse)
+async def create_note(
+    request: Request,
+    slug: str = Form(...),
+    content: str = Form(...),
+    is_private: bool = Form(False),
+    password: Optional[str] = Form(None),
+    db: Session = Depends(get_db)
+):
+    # Check if slug already exists
+    if db.query(Note).filter(Note.code == slug).first():
+        raise HTTPException(status_code=400, detail="Slug already exists. Choose a different one.")
+    
+    hashed_password = None
+    if is_private and password:
+        hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+    
+    new_note = Note(
+        code=slug,
+        content=content,
+        is_private=is_private,
+        password=hashed_password
+    )
+    db.add(new_note)
+    db.commit()
+    
+    return RedirectResponse(url=f"{BASE_URL}/{slug}", status_code=303)
+
+# POST /{slug}/verify: Verify password for private notes
+@app.post("/{slug}/verify", response_class=HTMLResponse)
+async def verify_password(
+    request: Request,
+    slug: str,
+    password: str = Form(...),
+    db: Session = Depends(get_db)
+):
+    note = db.query(Note).filter(Note.code == slug).first()
+    if not note:
+        raise HTTPException(status_code=404, detail="Note not found")
+    
+    if not note.is_private or not note.password:
+        return RedirectResponse(url=f"{BASE_URL}/{slug}", status_code=303)
+    
+    is_valid = bcrypt.checkpw(password.encode('utf-8'), note.password.encode('utf-8'))
+    if not is_valid:
+        return templates.TemplateResponse("password.html", {"request": request, "slug": slug, "error": "Invalid password", "error_effect": True})
+    
+    processed_content = process_content(note.content)
+    return templates.TemplateResponse("view.html", {"request": request, "note": note, "content": processed_content})
+
+# Landing page: If no slug provided, auto-generate one for the creation form
+@app.get("/", response_class=HTMLResponse)
+async def landing(request: Request):
+    random_slug = generate_random_code()
+    return templates.TemplateResponse("index.html", {"request": request, "slug": random_slug})
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)