Upload 32 files

.dockerignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.sqlite3
+
+# Environment
+.env
+.env.*
+venn/
+*.log
+
+# IDE/editor
+.DS_Store
+.idea/
+.vscode/
+
+# Uploads (optional if using CDN or cloud)
+static/uploads/*

.env

@@ -0,0 +1,13 @@
+# .env
+DATABASE_URL=postgresql://neondb_owner:npg_o5XMimeA8tnZ@ep-super-haze-a1dd768a-pooler.ap-southeast-1.aws.neon.tech/neondb?sslmode=require&channel_binding=require
+JWT_SECRET_KEY=your_secret_access_key
+JWT_REFRESH_SECRET_KEY=your_refresh_secret_key
+ALGORITHM=HS256
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+REFRESH_TOKEN_EXPIRE_DAYS=7
+EMAIL_HOST=smtp.yourprovider.com
+EMAIL_PORT=587
+EMAIL_USER=your@email.com
+EMAIL_PASS=your_email_password
+ALLOWED_ORIGINS_RAW=*
+RATE_LIMIT=5

.gitignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.sqlite3
+
+# Environment
+.env
+.env.*
+venn/
+*.log
+
+# IDE/editor
+.DS_Store
+.idea/
+.vscode/
+
+# Uploads (optional if using CDN or cloud)
+static/uploads/*

Dockerfile

@@ -0,0 +1,71 @@
+# Dockerfile
+
+FROM python:3.10
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Create app directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Copy source code
+COPY . .
+
+# Expose port
+EXPOSE 8000
+
+# Run the app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+
+
+# docker-compose.yml
+version: "3.9"
+services:
+  fastapi:
+    build: .
+    container_name: portfolio-api
+    ports:
+      - "8000:8000"
+    volumes:
+      - .:/app
+    env_file:
+      - .env
+    depends_on:
+      - db
+
+  db:
+    image: postgres:15
+    container_name: postgres-db
+    restart: always
+    environment:
+      POSTGRES_USER: youruser
+      POSTGRES_PASSWORD: yourpassword
+      POSTGRES_DB: yourdb
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+volumes:
+  postgres_data:
+
+
+# .dockerignore
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.sqlite3
+.env
+venv/
+.env.*
+*.log
+.DS_Store
+.idea/
+.vscode/
+static/uploads/*

admin.py

@@ -0,0 +1,23 @@
+from app.database import SessionLocal
+from app.models import User
+from app.auth import get_password_hash
+import uuid
+from datetime import datetime
+
+db = SessionLocal()
+
+user = User(
+    id=uuid.uuid4(),
+    email="shakauthossain0@gmail.com",
+    password_hash=get_password_hash("bangladesh"),
+    full_name="Admin User",
+    is_active=True,
+    created_at=datetime.utcnow(),
+    updated_at=datetime.utcnow()
+)
+
+db.add(user)
+db.commit()
+db.refresh(user)
+
+print("✅ User created:", user.email)

app/auth.py

@@ -0,0 +1,54 @@
+# Directory: app/auth.py
+
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from fastapi import Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from app import models, schemas
+from app.database import get_db
+from app.config import settings
+from uuid import UUID
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# --- Password Hashing ---
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+# --- JWT Utility ---
+def create_access_token(data: dict, expires_delta: timedelta):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + expires_delta
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.JWT_SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt
+
+def create_refresh_token(data: dict, expires_delta: timedelta):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + expires_delta
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.JWT_REFRESH_SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt
+
+# --- Auth Dependency ---
+def get_current_user(token: str = Depends(schemas.oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.JWT_SECRET_KEY, algorithms=[settings.ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    user = db.query(models.User).filter(models.User.id == UUID(user_id)).first()
+    if user is None:
+        raise credentials_exception
+    return user

app/config.py

@@ -0,0 +1,25 @@
+from pydantic_settings import BaseSettings
+from typing import List
+
+class Settings(BaseSettings):
+    DATABASE_URL: str
+    JWT_SECRET_KEY: str
+    JWT_REFRESH_SECRET_KEY: str
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+    REFRESH_TOKEN_EXPIRE_DAYS: int = 7
+    ALLOWED_ORIGINS_RAW: str = ""
+    EMAIL_HOST: str
+    EMAIL_PORT: int
+    EMAIL_USER: str
+    EMAIL_PASS: str
+    RATE_LIMIT: int = 5
+
+    class Config:
+        env_file = ".env"
+        
+    @property
+    def ALLOWED_ORIGINS(self) -> List[str]:
+        return [origin.strip() for origin in self.ALLOWED_ORIGINS_RAW.split(",") if origin.strip()]
+
+settings = Settings()

app/database.py

@@ -0,0 +1,16 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from app.config import settings
+
+engine = create_engine(settings.DATABASE_URL)
+SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
+Base = declarative_base()
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/models.py

@@ -0,0 +1,148 @@
+# Directory: app/models.py
+
+import uuid
+from datetime import datetime, date
+from sqlalchemy import Column, String, Boolean, DateTime, Text, Enum, Integer, ForeignKey, Date, JSON
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import relationship
+from app.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    email = Column(String, unique=True, index=True, nullable=False)
+    password_hash = Column(String, nullable=False)
+    full_name = Column(String, nullable=False)
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class Hero(Base):
+    __tablename__ = "hero"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    title = Column(String)
+    subtitle = Column(String)
+    description = Column(Text)
+    cta_text = Column(String)
+    cta_link = Column(String)
+    background_image = Column(String)
+    profile_image = Column(String)
+    animation_style = Column(String)
+    show_scroll_indicator = Column(Boolean, default=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class About(Base):
+    __tablename__ = "about"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    title = Column(String)
+    introduction = Column(Text)
+    description = Column(Text)
+    profile_image = Column(String)
+    highlights = Column(JSON)
+    skills = Column(JSON)
+    location = Column(String)
+    availability = Column(String)
+    email = Column(String)
+    phone = Column(String)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class Experience(Base):
+    __tablename__ = "experiences"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    title = Column(String)
+    company = Column(String)
+    location = Column(String)
+    start_date = Column(Date)
+    end_date = Column(Date, nullable=True)
+    is_current = Column(Boolean, default=False)
+    description = Column(Text)
+    technologies = Column(JSON)
+    achievements = Column(JSON)
+    display_order = Column(Integer)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class Project(Base):
+    __tablename__ = "projects"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    title = Column(String)
+    description = Column(String)
+    long_description = Column(Text)
+    image = Column(String)
+    technologies = Column(JSON)
+    category = Column(String)
+    status = Column(Enum("completed", "in-progress", "planned", name="project_status"))
+    is_featured = Column(Boolean, default=False)
+    github_url = Column(String, nullable=True)
+    live_url = Column(String, nullable=True)
+    start_date = Column(Date)
+    end_date = Column(Date, nullable=True)
+    highlights = Column(JSON)
+    display_order = Column(Integer)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class SkillCategory(Base):
+    __tablename__ = "skill_categories"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    name = Column(String)
+    color = Column(String)
+    description = Column(String)
+    display_order = Column(Integer)
+
+class Skill(Base):
+    __tablename__ = "skills"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    name = Column(String)
+    category_id = Column(UUID(as_uuid=True), ForeignKey("skill_categories.id"))
+    proficiency = Column(Integer)
+    years_of_experience = Column(Integer)
+    icon = Column(String, nullable=True)
+    is_featured = Column(Boolean, default=False)
+    display_order = Column(Integer)
+    
+
+class BlogPost(Base):
+    __tablename__ = "blog_posts"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    title = Column(String)
+    slug = Column(String, unique=True)
+    excerpt = Column(Text)
+    content = Column(Text)
+    author = Column(String)
+    publish_date = Column(Date)
+    status = Column(Enum("draft", "published", "scheduled", name="blog_status"))
+    is_featured = Column(Boolean, default=False)
+    image = Column(String)
+    tags = Column(JSON)
+    category = Column(String)
+    read_time = Column(Integer)
+    seo_title = Column(String)
+    seo_description = Column(String)
+    views = Column(Integer, default=0)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class Certification(Base):
+    __tablename__ = "certifications"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    name = Column(String)
+    issuer = Column(String)
+    issue_date = Column(Date)
+    expiry_date = Column(Date, nullable=True)
+    credential_id = Column(String, nullable=True)
+    verification_url = Column(String, nullable=True)
+    image = Column(String, nullable=True)
+    description = Column(Text, nullable=True)
+    is_featured = Column(Boolean, default=False)
+    display_order = Column(Integer)
+
+class ContactMessage(Base):
+    __tablename__ = "contact_messages"
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    name = Column(String)
+    email = Column(String)
+    subject = Column(String)
+    message = Column(Text)
+    is_read = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=datetime.utcnow)

app/routes/about.py

@@ -0,0 +1,29 @@
+# Directory: app/routes/about.py
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from app import models, schemas
+from app.database import get_db
+from app.auth import get_current_user
+
+router = APIRouter(tags=["About"])
+
+@router.get("/", response_model=schemas.AboutResponse)
+def get_about(db: Session = Depends(get_db)):
+    about = db.query(models.About).first()
+    if not about:
+        raise HTTPException(status_code=404, detail="About section not found")
+    return about
+
+@router.put("/", response_model=schemas.AboutResponse)
+def update_about(update: schemas.AboutBase, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    about = db.query(models.About).first()
+    if not about:
+        about = models.About(**update.dict())
+        db.add(about)
+    else:
+        for key, value in update.dict(exclude_unset=True).items():
+            setattr(about, key, value)
+    db.commit()
+    db.refresh(about)
+    return about

app/routes/auth.py

@@ -0,0 +1,52 @@
+# Directory: app/routes/auth.py
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from fastapi.security import OAuth2PasswordRequestForm
+from datetime import timedelta
+from app import models, schemas
+from app.auth import verify_password, get_password_hash, create_access_token, create_refresh_token
+from app.database import get_db
+from app.config import settings
+from jose import JWTError, jwt
+from app.auth import get_current_user
+from app.schemas import UserOut
+from fastapi.responses import JSONResponse
+
+router = APIRouter(tags=["Authentication"])
+
+@router.post("/login", response_model=schemas.Token)
+def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
+    user = db.query(models.User).filter(models.User.email == form_data.username).first()
+    if not user or not verify_password(form_data.password, user.password_hash):
+        raise HTTPException(status_code=401, detail="Incorrect email or password")
+
+    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    refresh_token_expires = timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS)
+
+    access_token = create_access_token(data={"sub": str(user.id)}, expires_delta=access_token_expires)
+    refresh_token = create_refresh_token(data={"sub": str(user.id)}, expires_delta=refresh_token_expires)
+
+    return {"access_token": access_token, "refresh_token": refresh_token, "token_type": "bearer"}
+
+@router.post("/refresh", response_model=schemas.Token)
+def refresh_token(refresh_token: str, db: Session = Depends(get_db)):
+    try:
+        payload = jwt.decode(refresh_token, settings.JWT_REFRESH_SECRET_KEY, algorithms=[settings.ALGORITHM])
+        user_id = payload.get("sub")
+    except:
+        raise HTTPException(status_code=401, detail="Invalid refresh token")
+
+    user = db.query(models.User).filter(models.User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=401, detail="User not found")
+
+    access_token = create_access_token(data={"sub": str(user.id)}, expires_delta=timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES))
+    refresh_token = create_refresh_token(data={"sub": str(user.id)}, expires_delta=timedelta(days=settings.REFRESH_TOKEN_EXPIRE_DAYS))
+
+    return {"access_token": access_token, "refresh_token": refresh_token, "token_type": "bearer"}
+
+@router.post("/logout", status_code=status.HTTP_200_OK)
+def logout(user: UserOut = Depends(get_current_user)):
+    # Invalidate token logic would go here if you used a blacklist
+    return JSONResponse(content={"message": "Logout successful."})

app/routes/blog.py

@@ -0,0 +1,62 @@
+# Directory: app/routes/blog.py
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+from app import models, schemas
+from app.database import get_db
+from app.auth import get_current_user
+import uuid
+
+router = APIRouter(tags=["Blog"])
+
+@router.get("/", response_model=list[schemas.BlogPostResponse])
+def list_posts(skip: int = 0, limit: int = 10, search: str = Query(""), db: Session = Depends(get_db)):
+    query = db.query(models.BlogPost)
+    if search:
+        query = query.filter(
+            or_(
+                models.BlogPost.title.ilike(f"%{search}%"),
+                models.BlogPost.excerpt.ilike(f"%{search}%"),
+                models.BlogPost.tags.cast(str).ilike(f"%{search}%")
+            )
+        )
+    return query.order_by(models.BlogPost.publish_date.desc()).offset(skip).limit(limit).all()
+
+@router.get("/{slug}", response_model=schemas.BlogPostResponse)
+def get_post(slug: str, db: Session = Depends(get_db)):
+    post = db.query(models.BlogPost).filter(models.BlogPost.slug == slug).first()
+    if not post:
+        raise HTTPException(status_code=404, detail="Post not found")
+    post.views += 1
+    db.commit()
+    db.refresh(post)
+    return post
+
+@router.post("/", response_model=schemas.BlogPostResponse)
+def create_post(payload: schemas.BlogPostCreate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    post = models.BlogPost(**payload.dict())
+    db.add(post)
+    db.commit()
+    db.refresh(post)
+    return post
+
+@router.put("/{id}", response_model=schemas.BlogPostResponse)
+def update_post(id: uuid.UUID, payload: schemas.BlogPostUpdate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    post = db.query(models.BlogPost).filter(models.BlogPost.id == id).first()
+    if not post:
+        raise HTTPException(status_code=404, detail="Post not found")
+    for key, value in payload.dict(exclude_unset=True).items():
+        setattr(post, key, value)
+    db.commit()
+    db.refresh(post)
+    return post
+
+@router.delete("/{id}", response_model=schemas.Msg)
+def delete_post(id: uuid.UUID, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    post = db.query(models.BlogPost).filter(models.BlogPost.id == id).first()
+    if not post:
+        raise HTTPException(status_code=404, detail="Post not found")
+    db.delete(post)
+    db.commit()
+    return {"detail": "Deleted successfully"}

app/routes/certifications.py

@@ -0,0 +1,42 @@
+# Directory: app/routes/certifications.py
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from uuid import UUID
+from app import models, schemas
+from app.database import get_db
+from app.auth import get_current_user
+
+router = APIRouter(tags=["Certifications"])
+
+@router.get("/", response_model=list[schemas.CertificationResponse])
+def list_certifications(db: Session = Depends(get_db)):
+    return db.query(models.Certification).order_by(models.Certification.display_order.asc()).all()
+
+@router.post("/", response_model=schemas.CertificationResponse)
+def create_certification(payload: schemas.CertificationCreate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    cert = models.Certification(**payload.dict())
+    db.add(cert)
+    db.commit()
+    db.refresh(cert)
+    return cert
+
+@router.put("/{id}", response_model=schemas.CertificationResponse)
+def update_certification(id: UUID, payload: schemas.CertificationUpdate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    cert = db.query(models.Certification).filter(models.Certification.id == id).first()
+    if not cert:
+        raise HTTPException(status_code=404, detail="Certification not found")
+    for key, value in payload.dict(exclude_unset=True).items():
+        setattr(cert, key, value)
+    db.commit()
+    db.refresh(cert)
+    return cert
+
+@router.delete("/{id}", response_model=schemas.Msg)
+def delete_certification(id: UUID, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    cert = db.query(models.Certification).filter(models.Certification.id == id).first()
+    if not cert:
+        raise HTTPException(status_code=404, detail="Certification not found")
+    db.delete(cert)
+    db.commit()
+    return {"detail": "Deleted successfully"}

app/routes/contact.py

@@ -0,0 +1,45 @@
+# Directory: app/routes/contact.py
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from app import models, schemas
+from app.database import get_db
+from app.utils.email_utils import send_contact_email
+from app.auth import get_current_user
+import uuid
+
+router = APIRouter(tags=["Contact"])
+
+@router.post("/", response_model=schemas.Msg)
+def submit_message(payload: schemas.ContactMessageCreate, db: Session = Depends(get_db)):
+    success = send_contact_email(payload.name, payload.email, payload.subject, payload.message)
+
+    message = models.ContactMessage(**payload.dict())
+    db.add(message)
+    db.commit()
+
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to send email")
+    return {"detail": "Message sent successfully"}
+
+@router.get("/messages", response_model=list[schemas.ContactMessageResponse])
+def list_messages(db: Session = Depends(get_db), user=Depends(get_current_user)):
+    return db.query(models.ContactMessage).order_by(models.ContactMessage.created_at.desc()).all()
+
+@router.put("/messages/{id}/read", response_model=schemas.Msg)
+def mark_as_read(id: uuid.UUID, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    message = db.query(models.ContactMessage).filter(models.ContactMessage.id == id).first()
+    if not message:
+        raise HTTPException(status_code=404, detail="Message not found")
+    message.is_read = True
+    db.commit()
+    return {"detail": "Marked as read"}
+
+@router.delete("/messages/{id}", response_model=schemas.Msg)
+def delete_message(id: uuid.UUID, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    message = db.query(models.ContactMessage).filter(models.ContactMessage.id == id).first()
+    if not message:
+        raise HTTPException(status_code=404, detail="Message not found")
+    db.delete(message)
+    db.commit()
+    return {"detail": "Deleted successfully"}

app/routes/experience.py

@@ -0,0 +1,60 @@
+# Directory: app/routes/experience.py
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+from app import models, schemas
+from app.database import get_db
+from app.auth import get_current_user
+from uuid import UUID
+
+router = APIRouter(tags=["Experience"])
+
+@router.get("/", response_model=list[schemas.ExperienceResponse])
+def get_experiences(db: Session = Depends(get_db)):
+    return db.query(models.Experience).order_by(models.Experience.display_order.asc()).all()
+
+@router.post("/", response_model=schemas.ExperienceResponse)
+async def create_experience(
+    request: Request,
+    db: Session = Depends(get_db),
+    user=Depends(get_current_user)
+):
+    body = await request.body()
+    print("🔍 RAW BODY:", body.decode())
+
+    from fastapi.encoders import jsonable_encoder
+    from pydantic import ValidationError
+    import json
+
+    try:
+        data = json.loads(body)
+        payload = schemas.ExperienceCreate(**data)
+    except ValidationError as ve:
+        print("❌ VALIDATION ERROR:", ve)
+        raise HTTPException(status_code=422, detail=ve.errors())
+
+    exp = models.Experience(**payload.dict())
+    db.add(exp)
+    db.commit()
+    db.refresh(exp)
+    return exp
+
+@router.put("/{id}", response_model=schemas.ExperienceResponse)
+def update_experience(id: UUID, payload: schemas.ExperienceUpdate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    exp = db.query(models.Experience).filter(models.Experience.id == id).first()
+    if not exp:
+        raise HTTPException(status_code=404, detail="Experience not found")
+    for key, value in payload.dict(exclude_unset=True).items():
+        setattr(exp, key, value)
+    db.commit()
+    db.refresh(exp)
+    return exp
+
+@router.delete("/{id}", response_model=schemas.Msg)
+def delete_experience(id: UUID, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    exp = db.query(models.Experience).filter(models.Experience.id == id).first()
+    if not exp:
+        raise HTTPException(status_code=404, detail="Experience not found")
+    db.delete(exp)
+    db.commit()
+    return {"detail": "Deleted successfully"}

app/routes/health.py

@@ -0,0 +1,9 @@
+# Directory: app/routes/health.py
+
+from fastapi import APIRouter
+
+router = APIRouter(tags=["Health"])
+
+@router.get("/", summary="Health Check")
+def health_check():
+    return {"status": "ok"}

app/routes/hero.py

@@ -0,0 +1,29 @@
+# Directory: app/routes/hero.py
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from app import models, schemas
+from app.database import get_db
+from app.auth import get_current_user
+
+router = APIRouter(tags=["Hero"])
+
+@router.get("/", response_model=schemas.HeroResponse)
+def get_hero(db: Session = Depends(get_db)):
+    hero = db.query(models.Hero).first()
+    if not hero:
+        raise HTTPException(status_code=404, detail="Hero section not found")
+    return hero
+
+@router.put("/", response_model=schemas.HeroResponse)
+def update_hero(update: schemas.HeroUpdate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    hero = db.query(models.Hero).first()
+    if not hero:
+        hero = models.Hero(**update.dict())
+        db.add(hero)
+    else:
+        for key, value in update.dict(exclude_unset=True).items():
+            setattr(hero, key, value)
+    db.commit()
+    db.refresh(hero)
+    return hero

app/routes/projects.py

@@ -0,0 +1,55 @@
+# Directory: app/routes/projects.py
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from app import models, schemas
+from app.database import get_db
+from app.auth import get_current_user
+from uuid import UUID
+
+router = APIRouter(tags=["Projects"])
+
+@router.get("/", response_model=list[schemas.ProjectResponse])
+def list_projects(category: str = Query(None), featured: bool = Query(None), db: Session = Depends(get_db)):
+    query = db.query(models.Project)
+    if category:
+        query = query.filter(models.Project.category == category)
+    if featured is not None:
+        query = query.filter(models.Project.is_featured == featured)
+    return query.order_by(models.Project.display_order.asc()).all()
+
+@router.get("/{id}", response_model=schemas.ProjectResponse)
+def get_project(id: UUID, db: Session = Depends(get_db)):
+    project = db.query(models.Project).filter(models.Project.id == id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+    return project
+
+@router.post("/", response_model=schemas.ProjectResponse)
+def create_project(payload: schemas.ProjectCreate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    project = models.Project(**payload.dict())
+    print(payload)
+    db.add(project)
+    db.commit()
+    db.refresh(project)
+    return project
+
+@router.put("/{id}", response_model=schemas.ProjectResponse)
+def update_project(id: UUID, payload: schemas.ProjectUpdate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    project = db.query(models.Project).filter(models.Project.id == id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+    for key, value in payload.dict(exclude_unset=True).items():
+        setattr(project, key, value)
+    db.commit()
+    db.refresh(project)
+    return project
+
+@router.delete("/{id}", response_model=schemas.Msg)
+def delete_project(id: UUID, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    project = db.query(models.Project).filter(models.Project.id == id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+    db.delete(project)
+    db.commit()
+    return {"detail": "Deleted successfully"}

app/routes/skills.py

@@ -0,0 +1,76 @@
+# Directory: app/routes/skills.py
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from uuid import UUID
+from app import models, schemas
+from app.database import get_db
+from app.auth import get_current_user
+
+router = APIRouter(tags=["Skills"])
+
+# Skill Categories
+@router.get("/categories", response_model=list[schemas.SkillCategoryResponse])
+def get_categories(db: Session = Depends(get_db)):
+    return db.query(models.SkillCategory).order_by(models.SkillCategory.display_order.asc()).all()
+
+@router.post("/categories", response_model=schemas.SkillCategoryResponse)
+def create_category(payload: schemas.SkillCategoryCreate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    category = models.SkillCategory(**payload.dict())
+    db.add(category)
+    db.commit()
+    db.refresh(category)
+    return category
+
+@router.put("/categories/{id}", response_model=schemas.SkillCategoryResponse)
+def update_category(id: UUID, payload: schemas.SkillCategoryUpdate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    category = db.query(models.SkillCategory).filter(models.SkillCategory.id == id).first()
+    if not category:
+        raise HTTPException(status_code=404, detail="Category not found")
+    for key, value in payload.dict(exclude_unset=True).items():
+        setattr(category, key, value)
+    db.commit()
+    db.refresh(category)
+    return category
+
+@router.delete("/categories/{id}", response_model=schemas.Msg)
+def delete_category(id: UUID, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    category = db.query(models.SkillCategory).filter(models.SkillCategory.id == id).first()
+    if not category:
+        raise HTTPException(status_code=404, detail="Category not found")
+    db.delete(category)
+    db.commit()
+    return {"detail": "Deleted successfully"}
+
+# Skills
+@router.get("/", response_model=list[schemas.SkillResponse])
+def get_skills(db: Session = Depends(get_db)):
+    return db.query(models.Skill).order_by(models.Skill.display_order.asc()).all()
+
+@router.post("/", response_model=schemas.SkillResponse)
+def create_skill(payload: schemas.SkillCreate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    skill = models.Skill(**payload.dict())
+    db.add(skill)
+    db.commit()
+    db.refresh(skill)
+    return skill
+
+@router.put("/{id}", response_model=schemas.SkillResponse)
+def update_skill(id: UUID, payload: schemas.SkillUpdate, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    skill = db.query(models.Skill).filter(models.Skill.id == id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="Skill not found")
+    for key, value in payload.dict(exclude_unset=True).items():
+        setattr(skill, key, value)
+    db.commit()
+    db.refresh(skill)
+    return skill
+
+@router.delete("/{id}", response_model=schemas.Msg)
+def delete_skill(id: UUID, db: Session = Depends(get_db), user=Depends(get_current_user)):
+    skill = db.query(models.Skill).filter(models.Skill.id == id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="Skill not found")
+    db.delete(skill)
+    db.commit()
+    return {"detail": "Deleted successfully"}

app/routes/upload.py

@@ -0,0 +1,28 @@
+import os
+import uuid
+from fastapi import APIRouter, UploadFile, File, HTTPException, status
+from fastapi.responses import JSONResponse
+
+UPLOAD_DIR = "static/uploads"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+router = APIRouter(tags=["Upload"])
+
+@router.post("/upload")
+def upload_image(file: UploadFile = File(...)):
+    try:
+        extension = file.filename.split(".")[-1]
+        if extension.lower() not in ("jpg", "jpeg", "png", "gif", "webp", "ico"):
+            raise HTTPException(status_code=400, detail="Unsupported file type")
+
+        file_id = f"{uuid.uuid4()}.{extension}"
+        file_path = os.path.join(UPLOAD_DIR, file_id)
+
+        with open(file_path, "wb") as buffer:
+            buffer.write(file.file.read())
+
+        file_url = f"/static/uploads/{file_id}"
+        return JSONResponse(status_code=status.HTTP_201_CREATED, content={"url": file_url})
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"File upload failed: {str(e)}")

app/schemas.py

@@ -0,0 +1,232 @@
+# Directory: app/schemas.py
+
+from datetime import datetime, date
+from typing import Optional, List
+from pydantic import BaseModel, EmailStr, Field, validator
+from uuid import UUID
+from fastapi.security import OAuth2PasswordBearer
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
+
+# --- Shared Schemas ---
+class Msg(BaseModel):
+    detail: str
+
+# --- User ---
+class UserBase(BaseModel):
+    email: EmailStr
+    full_name: str
+
+class UserCreate(UserBase):
+    password: str
+
+class UserOut(UserBase):
+    id: UUID
+    is_active: bool
+    created_at: datetime
+    updated_at: datetime
+
+# --- Token ---
+class Token(BaseModel):
+    access_token: str
+    refresh_token: str
+    token_type: str = "bearer"
+
+# --- Hero ---
+class HeroBase(BaseModel):
+    title: str
+    subtitle: str
+    description: str
+    cta_text: str
+    cta_link: str
+    background_image: str
+    profile_image: str
+    animation_style: str
+    show_scroll_indicator: bool
+
+class HeroUpdate(HeroBase):
+    pass
+
+class HeroResponse(HeroBase):
+    id: UUID
+    updated_at: datetime
+
+# --- About ---
+class AboutBase(BaseModel):
+    title: str
+    introduction: str
+    description: str
+    profile_image: str
+    highlights: List[str]
+    skills: List[str]
+    location: str
+    availability: str
+    email: str
+    phone: str
+
+class AboutResponse(AboutBase):
+    id: UUID
+    updated_at: datetime
+
+# --- Experience ---
+class ExperienceBase(BaseModel):
+    title: Optional[str] = None
+    company: Optional[str] = None
+    location: Optional[str] = None
+    start_date: date = Field(..., alias="startDate")
+    end_date: Optional[date] = Field(None, alias="endDate")
+    is_current: Optional[bool] = Field(None, alias="current")
+    description: Optional[str] = None
+    technologies: Optional[List[str]] = None
+    achievements: Optional[List[str]] = None
+    display_order: Optional[int] = None
+
+    class Config:
+        allow_population_by_field_name = True
+
+class ExperienceCreate(ExperienceBase):
+    @validator("start_date", "end_date", pre=True)
+    def parse_partial_date(cls, value):
+        if value == "":
+            return None
+        if isinstance(value, str) and len(value) == 7:
+            return datetime.strptime(value + "-01", "%Y-%m-%d").date()
+        return value
+
+class ExperienceUpdate(ExperienceBase):
+    pass
+
+class ExperienceResponse(ExperienceBase):
+    id: UUID
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        orm_mode = True
+        populate_by_name = True
+
+# --- Project ---
+class ProjectBase(BaseModel):
+    title: str
+    description: str
+    long_description: str
+    image: Optional[str] = None
+    technologies: List[str] = []
+    category: str
+    status: str
+    is_featured: bool
+    github_url: Optional[str] = None
+    live_url: Optional[str] = None
+    start_date: date
+    end_date: Optional[date] = None
+    highlights: List[str] = []
+    display_order: int
+
+class ProjectCreate(ProjectBase):
+    pass
+
+class ProjectUpdate(ProjectBase):
+    pass
+
+class ProjectResponse(ProjectBase):
+    id: UUID
+    created_at: datetime
+    updated_at: datetime
+
+# --- Skill Category ---
+class SkillCategoryBase(BaseModel):
+    name: str
+    color: str
+    description: str
+    display_order: Optional[int] = None
+
+class SkillCategoryCreate(SkillCategoryBase):
+    pass
+
+class SkillCategoryUpdate(SkillCategoryBase):
+    pass
+
+class SkillCategoryResponse(SkillCategoryBase):
+    id: UUID
+
+# --- Skill ---
+class SkillBase(BaseModel):
+    name: str
+    category_id: UUID
+    proficiency: int
+    years_of_experience: int
+    icon: Optional[str]
+    is_featured: bool
+    display_order: Optional[int] = None
+
+class SkillCreate(SkillBase):
+    pass
+
+class SkillUpdate(SkillBase):
+    pass
+
+class SkillResponse(SkillBase):
+    id: UUID
+
+# --- Blog ---
+class BlogPostBase(BaseModel):
+    title: str
+    slug: str
+    excerpt: str
+    content: str
+    author: str
+    publish_date: date
+    status: str
+    is_featured: bool
+    image: Optional[str] = None
+    tags: List[str]
+    category: str
+    read_time: int
+    seo_title: str
+    seo_description: str
+
+class BlogPostCreate(BlogPostBase):
+    pass
+
+class BlogPostUpdate(BlogPostBase):
+    pass
+
+class BlogPostResponse(BlogPostBase):
+    id: UUID
+    views: int
+    created_at: datetime
+    updated_at: datetime
+
+# --- Certification ---
+class CertificationBase(BaseModel):
+    name: str
+    issuer: str
+    issue_date: date
+    expiry_date: Optional[date]
+    credential_id: Optional[str]
+    verification_url: Optional[str]
+    image: Optional[str]
+    description: Optional[str]
+    is_featured: bool
+    display_order: int
+
+class CertificationCreate(CertificationBase):
+    pass
+
+class CertificationUpdate(CertificationBase):
+    pass
+
+class CertificationResponse(CertificationBase):
+    id: UUID
+
+# --- Contact Message ---
+class ContactMessageCreate(BaseModel):
+    name: str
+    email: str
+    subject: str
+    message: str
+
+class ContactMessageResponse(ContactMessageCreate):
+    id: UUID
+    is_read: bool
+    created_at: datetime

app/utils/email_utils.py

@@ -0,0 +1,33 @@
+# File: app/utils/email_utils.py
+
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from app.config import settings
+
+def send_contact_email(name: str, email: str, subject: str, message: str):
+    msg = MIMEMultipart()
+    msg['From'] = settings.EMAIL_USER
+    msg['To'] = settings.EMAIL_USER
+    msg['Subject'] = f"[Portfolio Contact] {subject}"
+
+    body = f"""
+    Name: {name}
+    Email: {email}
+    Subject: {subject}
+
+    Message:
+    {message}
+    """
+    msg.attach(MIMEText(body, 'plain'))
+
+    try:
+        server = smtplib.SMTP(settings.EMAIL_HOST, settings.EMAIL_PORT)
+        server.starttls()
+        server.login(settings.EMAIL_USER, settings.EMAIL_PASS)
+        server.send_message(msg)
+        server.quit()
+        return True
+    except Exception as e:
+        print(f"Email sending failed: {e}")
+        return False

main.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.config import settings
+from app.database import engine, Base
+from fastapi.staticfiles import StaticFiles
+from app.routes import (
+    auth, hero, about, experience, projects, skills, blog, certifications, contact, health, upload
+)
+
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="Portfolio CMS API", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Routes
+app.include_router(auth.router, prefix="/auth")
+app.include_router(hero.router, prefix="/hero")
+app.include_router(about.router, prefix="/about")
+app.include_router(experience.router, prefix="/experience")
+app.include_router(projects.router, prefix="/projects")
+app.include_router(skills.router, prefix="/skills")
+app.include_router(blog.router, prefix="/blog")
+app.include_router(certifications.router, prefix="/certifications")
+app.include_router(contact.router, prefix="/contact")
+app.include_router(health.router, prefix="/health")
+app.include_router(upload.router, prefix="/upload")
+app.mount("/static", StaticFiles(directory="static"), name="static")

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn[standard]
+python-dotenv
+sqlalchemy
+psycopg2-binary
+passlib[bcrypt]
+python-jose
+python-multipart
+email-validator
+pydantic-settings