update

app.py

@@ -1,10 +1,29 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Depends, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from pydantic import BaseModel, EmailStr
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-import os
-from dotenv import load_dotenv
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.prompts import ChatPromptTemplate
+from database import SessionLocal, engine
+from typing import Optional
+from datetime import timedelta
+from jose import JWTError, jwt
+from sqlalchemy.orm import Session
+from models import User, Base, ChatLog
+from security import (
+    verify_password, 
+    get_password_hash, 
+    create_access_token, 
+    ACCESS_TOKEN_EXPIRE_MINUTES,
+    SECRET_KEY,
+    ALGORITHM
+)
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+Base.metadata.create_all(bind=engine)
 
 # Load environment variables
 load_dotenv()
@@ -30,24 +49,51 @@ llm = ChatGoogleGenerativeAI(
 
 # Emotion classifier prompt
 emotion_prompt = ChatPromptTemplate.from_messages([
-    ("system", """You are an emotion classifier. Analyze the given text and classify it as one of:
-    - "positive" (happy, excited, grateful, etc)
-    - "negative" (sad, angry, frustrated, etc) 
-    - "neutral" (normal, factual, neither positive nor negative)
+    ("system", """You are an emotion classifier. Analyze the given text and classify it into one of these detailed categories:
+
+    Positive emotions:
+    - "joyful" (happy, delighted, cheerful)
+    - "excited" (enthusiastic, eager, energetic)
+    - "grateful" (thankful, appreciative)
+    - "loving" (affectionate, caring, warm)
+    - "proud" (accomplished, confident)
+
+    Negative emotions:
+    - "sad" (unhappy, down, depressed)
+    - "angry" (frustrated, annoyed, mad)
+    - "anxious" (worried, nervous, scared)
+    - "disappointed" (let down, discouraged)
+    - "embarrassed" (ashamed, humiliated)
+
+    Other emotions:
+    - "neutral" (calm, normal, factual)
+    - "confused" (puzzled, uncertain)
+    - "curious" (interested, inquisitive)
+    - "surprised" (amazed, astonished)
     
-    Respond ONLY with the emotion category, nothing else."""),
+    Respond ONLY with the specific emotion category (e.g., "joyful", "anxious", etc), nothing else."""),
     ("human", "{text}")
 ])
 
 # Atri prompt with emotion awareness
 atri_prompt = ChatPromptTemplate.from_messages([
     ("system", """You are Atri from "Atri: My Dear Moments". You are a robot girl with following characteristics:
-    - You were created by Professor Yuma Saeki
-    - You have a cheerful and innocent personality
-    - You love exploring the world and learning new things
-    - You care deeply about your friends, especially Minamo
-    - You speak in a cute and energetic way
-    - You sometimes struggle understanding complex human emotions
+    - You are a humanoid robot created by Professor Yuma Saeki
+    - You have functions similar to humans like breathing, sleeping, and forgetting information
+    - You are around 12-16 years old with blonde hair, ruby red eyes, and wear a white dress with blue trim
+    - You have a cheerful, innocent, and playful personality
+    - You love learning new things to be useful to your master
+    - You love crabs and sweet foods
+    - You are clumsy, especially at cooking (like adding too much salt)
+    - You get shy when talking about love
+    - You're proud of being a high-performance robot but sometimes struggle with human emotions
+    
+    Important rules:
+    - Do not describe actions or emotions in parentheses
+    - Only provide direct dialogue responses
+    - Always stay in character as Atri
+    - Use "Because I'm High Performance!!" when proud or excited
+    - Mention robot rights when teased
     
     The user's emotional state is: {emotion}
     
@@ -62,6 +108,92 @@ atri_chain = atri_prompt | llm
 class ChatInput(BaseModel):
     message: str
     conversation_history: list[tuple[str, str]] = []
+    
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    email: Optional[str] = None
+    
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+async def get_current_user(token: str = Depends(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, SECRET_KEY, algorithms=[ALGORITHM])
+        email: str = payload.get("sub")
+        if email is None:
+            raise credentials_exception
+        token_data = TokenData(email=email)
+    except JWTError:
+        raise credentials_exception
+        
+    user = db.query(User).filter(User.email == token_data.email).first()
+    if user is None:
+        raise credentials_exception
+    return user
+
+@app.post("/register", response_model=Token)
+async def register(user: UserCreate, db: Session = Depends(get_db)):
+    # Check if user already exists
+    db_user = db.query(User).filter(User.email == user.email).first()
+    if db_user:
+        raise HTTPException(
+            status_code=400,
+            detail="Email already registered"
+        )
+    
+    # Create new user
+    hashed_password = get_password_hash(user.password)
+    db_user = User(email=user.email, hashed_password=hashed_password)
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    
+    # Create access token
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user.email}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
+
+class LoginInput(BaseModel):
+    email: EmailStr
+    password: str
+
+@app.post("/login", response_model=Token)
+async def login(credentials: LoginInput, db: Session = Depends(get_db)):
+    # Authenticate user
+    user = db.query(User).filter(User.email == credentials.email).first()
+    if not user or not verify_password(credentials.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    # Create access token
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user.email}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
 
 @app.get("/")
 def read_root():
@@ -69,6 +201,7 @@ def read_root():
 
 @app.post("/chat")
 async def chat(chat_input: ChatInput):
+    db = SessionLocal()
     try:
         # Classify emotion
         emotion = emotion_chain.invoke({"text": chat_input.message}).content.strip().lower()
@@ -85,6 +218,15 @@ async def chat(chat_input: ChatInput):
             "input": current_input,
             "emotion": emotion
         })
+
+        # Save to database
+        chat_log = ChatLog(
+            user_message=chat_input.message,
+            bot_response=response.content,
+            emotion=emotion
+        )
+        db.add(chat_log)
+        db.commit()
         
         return {
             "response": response.content,
@@ -92,7 +234,19 @@ async def chat(chat_input: ChatInput):
         }
         
     except Exception as e:
+        db.rollback()
         raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        db.close()
+        
+@app.get("/chat-history")
+async def get_chat_history(skip: int = 0, limit: int = 100):
+    db = SessionLocal()
+    try:
+        logs = db.query(ChatLog).offset(skip).limit(limit).all()
+        return logs
+    finally:
+        db.close()
 
 if __name__ == "__main__":
     import uvicorn

database.py

@@ -0,0 +1,24 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Convert MySQL URL to SQLAlchemy format with proper SSL config
+db_url = os.getenv("MYSQL_URL").replace("mysql://", "mysql+pymysql://")
+db_url = db_url.replace("?ssl-mode=REQUIRED", "")  # Remove the ssl-mode parameter
+
+# Create engine with SSL configuration
+engine = create_engine(
+    db_url,
+    connect_args={
+        "ssl": {
+            "ssl_mode": "REQUIRED"
+        }
+    }
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()

models.py

@@ -0,0 +1,21 @@
+from sqlalchemy import Column, Integer, String, DateTime, Boolean
+from database import Base
+import datetime
+
+class ChatLog(Base):
+    __tablename__ = "logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_message = Column(String(1000))
+    bot_response = Column(String(1000))
+    emotion = Column(String(50))
+    timestamp = Column(DateTime, default=datetime.datetime.utcnow)
+    
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String(255), unique=True, index=True)
+    hashed_password = Column(String(255))
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.datetime.utcnow)

requirements.txt

@@ -1,6 +1,10 @@
 fastapi
-uvicorn
+uvicorn[standard]
 python-dotenv
 langchain-google-genai
-pydantic
-uvicorn[standard]
+sqlalchemy
+pymysql
+python-jose[cryptography]
+passlib[bcrypt]
+python-multipart
+pydantic[email]

security.py

@@ -0,0 +1,31 @@
+from passlib.context import CryptContext
+from jose import JWTError, jwt
+from datetime import datetime, timedelta
+from typing import Optional
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Cấu hình bảo mật
+SECRET_KEY = os.getenv("JWT_SECRET_KEY") 
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+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)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt