app.py

from fastapi import FastAPI, Depends, HTTPException, status
from sqlalchemy.orm import Session
from sqlalchemy import create_engine, Column, Integer, String, Boolean, Enum
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from passlib.context import CryptContext
from jose import JWTError, jwt
import openai
from fastapi.middleware.cors import CORSMiddleware

# Configuration de la base de données MySQL
DATABASE_URL = "mysql+mysqlconnector://root:password@localhost/mobile_app"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Configuration JWT et hachage de mot de passe
SECRET_KEY = "your_secret_key"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

# Modèle pour les utilisateurs
class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(255), unique=True, index=True)
    passcode = Column(String(255))
    accept_terms = Column(Boolean)
    sex = Column(Enum('male', 'female'))
    age = Column(Integer)

Base.metadata.create_all(bind=engine)

app = FastAPI()

# Créer une session pour la base de données
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# Fonction pour vérifier le mot de passe haché
def verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

# Fonction pour hacher le mot de passe
def get_password_hash(password):
    return pwd_context.hash(password)

# Fonction pour créer un JWT token
def create_access_token(data: dict):
    to_encode = data.copy()
    token = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return token

# Schéma de données pour la création d'utilisateurs
from pydantic import BaseModel
class UserCreate(BaseModel):
    name: str
    passcode: str
    accept_terms: bool
    sex: str
    age: int

# Schéma de données pour l'authentification
class Token(BaseModel):
    access_token: str
    token_type: str

class UserLogin(BaseModel):
    name: str
    passcode: str

# Inscription d'un utilisateur
@app.post("/register/")
def register(user: UserCreate, db: Session = Depends(get_db)):
    hashed_password = get_password_hash(user.passcode)
    db_user = User(name=user.name, passcode=hashed_password, accept_terms=user.accept_terms, sex=user.sex, age=user.age)
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return {"message": "User registered successfully"}

# Connexion d'un utilisateur
@app.post("/login/", response_model=Token)
def login(user: UserLogin, db: Session = Depends(get_db)):
    db_user = db.query(User).filter(User.name == user.name).first()
    if not db_user:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
    if not verify_password(user.passcode, db_user.passcode):
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
    
    access_token = create_access_token(data={"sub": db_user.name})
    return {"access_token": access_token, "token_type": "bearer"}

# API protégée utilisant OpenAI après connexion
@app.post("/use_openai/")
def use_openai(db: Session = Depends(get_db), token: str = Depends(create_access_token)):
    # Appel à l'API OpenAI en utilisant la clé d'accès
    openai.api_key = "YOUR_OPENAI_API_KEY"
    
    # Exemple de requête OpenAI
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt="Hello, how are you?",
        max_tokens=50
    )
    
    return {"openai_response": response["choices"][0]["text"].strip()}