Spaces:
Sleeping
Sleeping
File size: 3,924 Bytes
d33c542 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
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()}
|