From 83389e0c100620508800722dc0cad7ce9553c1ee Mon Sep 17 00:00:00 2001 From: osbm Date: Mon, 5 May 2025 21:25:00 +0300 Subject: [PATCH 1/8] Revert "Merge pull request 'add updates to show bedir' (#14) from another into main" This reverts commit 99f611b3d0b224dd65980c1b2460bf3573795f33, reversing changes made to d5588dd055e06cc812af3dc02d2e2d190bce97b4. --- auth/models.py | 146 +++++++++++++++++++++++++++++++++++++++++------- auth/router.py | 86 ++++++++++++++-------------- auth/schemas.py | 23 -------- config.py | 35 ++++++------ items/models.py | 25 ++++----- items/router.py | 13 +++-- 6 files changed, 210 insertions(+), 118 deletions(-) delete mode 100644 auth/schemas.py diff --git a/auth/models.py b/auth/models.py index 41cb69f..7a3dd73 100644 --- a/auth/models.py +++ b/auth/models.py @@ -1,27 +1,135 @@ -from sqlalchemy import Column, Integer, String, Enum, DateTime -import enum, datetime +from enum import Enum +from backend.config import SECRET_KEY, ALGORITHM, ACCESS_TOKEN_EXPIRE_MINUTES +from backend.config import pwd_context, get_session_db +from datetime import datetime, timedelta, timezone +from pydantic import BaseModel +from fastapi import Depends, HTTPException +from typing import Annotated, Optional +from fastapi.security import OAuth2PasswordBearer +from passlib.context import CryptContext +import jwt +from sqlmodel import SQLModel, Field, Session, select +from pydantic.networks import EmailStr -from ..config import Base +class Token(BaseModel): + access_token: str + token_type: str -class Role(str, enum.Enum): - admin = "admin" + +### ENUMS ### +class Role(str, Enum): user = "user" + admin = "admin" + guest = "guest" mod = "mod" -class Status(str, enum.Enum): - banned = "banned" +class Status(str, Enum): active = "active" + banned = "banned" suspended = "suspended" -class User(Base): - __tablename__ = "users" - user_id = Column(Integer, primary_key=True) - username = Column(String, unique=True) - name = Column(String) - surname = Column(String) - hashedPassword = Column(String) - email = Column(String, unique=True) - role = Column(Enum(Role), default=Role.user) - status = Column(Enum(Status), default=Status.active) - bio = Column(String(144)) - created_date = Column(DateTime, default=datetime.datetime.utcnow) +### KULLANICI MODELLERİ ### +class UserBase(SQLModel): + username: Optional[str] = None + user_id: Optional[int] = None + role: Optional[Role] = None + status: Optional[Status] = None + +class UserInDb(UserBase): + hashed_password: str | None = None + +class UserPublic(UserBase): + pass + +class UserCreate(BaseModel): + username: Optional[str] = None + role: Optional[Role] = None + email : EmailStr | None = None + status: Optional[Status] = None + password : str | None = None + +### VERİTABANI MODELİ ### +class DBUser(SQLModel, table=True): + __tablename__ = "users" # opsiyonel, sqlmodel bunu otomatik de atar + user_id: Optional[int] = Field(default=None, primary_key=True) + username: str = Field(index=True, nullable=False) + hashed_password: str = Field(nullable=False) + role: Role = Field(default=Role.user) + status: Status = Field(default=Status.active) + + +### AUTH ### +oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login") + + +def verify_password(plain_password: str, hashed_password: str) -> bool: + return pwd_context.verify(plain_password, hashed_password) + +def get_password_hash(password: str) -> str: + return pwd_context.hash(password) + +def authenticate_user( + session: Annotated[Session, Depends(get_session_db)], + username: str, + password: str + ) -> UserInDb | None: + + statement = select(DBUser).where(DBUser.username == username) + result = session.exec(statement).first() + if not result or not verify_password(password, result.hashed_password): + return None + return result + + +def create_access_token( + data: dict, + expires_delta: Optional[timedelta] = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES), +) -> str: + to_encode = data.copy() + expire = datetime.now(timezone.utc) + expires_delta + to_encode.update({"exp": expire}) + encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm="HS256") + return encoded_jwt + + +async def get_user( + session: Annotated[Session, Depends(get_session_db)], + username: str + ) -> UserInDb | None: + + statement = select(DBUser).where(DBUser.username == username) + result = session.exec(statement).first() + return result + + +async def get_current_user( + token: Annotated[str, Depends(oauth2_scheme)], + session: Annotated[Session, Depends(get_session_db)] +) -> UserPublic: + + credentials_exception = HTTPException( + status_code=401, + detail="Invalid credentials", + headers={"WWW-Authenticate": "Bearer"}, + ) + try: + payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"]) + username: Optional[str] = payload.get("sub") + if username is None: + raise credentials_exception + except jwt.PyJWTError: + raise credentials_exception + + user = await get_user(session, username) + if user is None: + raise credentials_exception + return user + + +async def get_current_active_user( + current_user: Annotated[UserInDb, Depends(get_current_user)] +) -> UserPublic: + + if current_user.status == Status.banned: + raise HTTPException(status_code=400, detail="Inactive user") + return current_user diff --git a/auth/router.py b/auth/router.py index 92affa8..0b8517e 100644 --- a/auth/router.py +++ b/auth/router.py @@ -1,14 +1,15 @@ -import os - -from fastapi import APIRouter, HTTPException -import bcrypt -import jwt - +from fastapi import APIRouter, Depends, HTTPException, status +from .models import Token, UserPublic +from .models import authenticate_user, create_access_token +from datetime import timedelta +from ..auth.models import get_password_hash, verify_password +from typing import Annotated +from sqlmodel import Session +from ..config import get_session_db from fastapi import Depends -from sqlalchemy.orm import Session -from .models import User -from .schemas import UserCreate, UserOut, UserLogin -from ..config import get_db +from fastapi.security import OAuth2PasswordRequestForm +from .models import UserCreate, DBUser + router = APIRouter( prefix="/auth", @@ -17,40 +18,41 @@ router = APIRouter( dependencies=[], ) -def create_token(user: User): - return jwt.encode({"sub": user.username}, os.getenv("SECRET_KEY"), algorithm=os.getenv("ALGORITHM")) +@router.post('/login') +async def login_for_access_token( + form_data : Annotated[OAuth2PasswordRequestForm, Depends()], + session : Annotated[Session, Depends(get_session_db)], +) -> Token: -def verify_token(token: str): - try: - data = jwt.decode(token, os.getenv("SECRET_KEY"), algorithms=[os.getenv("ALGORITHM")]) - return data.get("sub") - except jwt.ExpiredSignatureError: - raise HTTPException(401, "Token expired") - except jwt.InvalidTokenError: - raise HTTPException(401, "Invalid token") + user = authenticate_user(session, form_data.username, form_data.password) + if not user: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Incorrect username or password", + headers={"WWW-Authenticate": "Bearer"}, + ) + access_token_expires = timedelta(minutes=30) + access_token = create_access_token( + data={"sub": user.username, "role": user.role, 'status': user.status}, expires_delta=access_token_expires + ) + return Token(access_token=access_token, token_type="bearer") -@router.post("/register") -def register(user: UserCreate, db: Session = Depends(get_db)): - if db.query(User).filter_by(username=user.username).first(): - raise HTTPException(400, "Username taken") - hashed = bcrypt.hashpw(user.password.encode(), bcrypt.gensalt()).decode() - db_user = User(**user.model_dump(exclude={"password"}), hashedPassword=hashed) - db.add(db_user) - db.commit() - return {"msg": "User created"} +@router.post('/register', response_model=UserPublic) +async def create_user( + session : Annotated[Session, Depends(get_session_db)], + user : Annotated[UserCreate, Depends()] +): + user_dict = user.dict() + print(user.password) + user_dict['hashed_password'] = get_password_hash(user.password) + print (user_dict['hashed_password']) -@router.post("/login") -def login(user: UserLogin, db: Session = Depends(get_db)): - db_user = db.query(User).filter_by(username=user.username).first() - if not db_user or not bcrypt.checkpw(user.password.encode(), db_user.hashedPassword.encode()): - raise HTTPException(401, "Invalid creds") - return {"token": create_token(db_user)} + if not verify_password(user.password, user_dict['hashed_password']): + raise HTTPException(status_code=400, detail="Password hashing failed") -@router.get("/me", response_model=UserOut) -def get_me(token: str, db: Session = Depends(get_db)): - username = verify_token(token) - if not username: - raise HTTPException(401, "Invalid token") - user = db.query(User).filter_by(username=username).first() - return user \ No newline at end of file + db_user = DBUser.model_validate(user_dict) + session.add(db_user) + session.commit() + session.refresh(db_user) + return db_user \ No newline at end of file diff --git a/auth/schemas.py b/auth/schemas.py deleted file mode 100644 index b9f3a16..0000000 --- a/auth/schemas.py +++ /dev/null @@ -1,23 +0,0 @@ -from pydantic import BaseModel, EmailStr -from .models import Role, Status - -class UserCreate(BaseModel): - username: str - name: str - surname: str - password: str - email: EmailStr - bio: str = "" - -class UserOut(BaseModel): - username: str - name: str - surname: str - email: EmailStr - role: Role - status: Status - bio: str - -class UserLogin(BaseModel): - username: str - password: str \ No newline at end of file diff --git a/config.py b/config.py index e4641c4..07d6e59 100644 --- a/config.py +++ b/config.py @@ -1,13 +1,17 @@ from sqlalchemy import create_engine -from sqlalchemy.orm import sessionmaker, declarative_base +from sqlalchemy.ext.declarative import declarative_base +from sqlalchemy.orm import sessionmaker from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware +from passlib.context import CryptContext +from sqlmodel import SQLModel, Field, Session from dotenv import load_dotenv import os load_dotenv() +# Veritabanı URL'sini oluştur DATABASE_URL = ( f"postgresql://{os.getenv('USERNAME_DB')}:" f"{os.getenv('PASSWORD_DB')}@" @@ -16,24 +20,16 @@ DATABASE_URL = ( f"{os.getenv('NAME_DB')}" ) +engine = create_engine(DATABASE_URL, echo=False) +def init_db(): + SQLModel.metadata.create_all(engine) -engine = create_engine(DATABASE_URL) -SessionLocal = sessionmaker(bind=engine) -Base = declarative_base() - -from .auth.models import * -from .items.models import * - -Base.metadata.create_all(bind=engine) +def get_session_db(): + with Session(engine) as session: + yield session -def get_db(): - db = SessionLocal() - try: - yield db - finally: - db.close() - +### SECRET KEY ### origins = [ "http://localhost", "http://localhost:8080", @@ -42,6 +38,10 @@ origins = [ ] app = FastAPI() +@app.on_event("startup") +def on_startup(): + init_db() + app.add_middleware( CORSMiddleware, allow_origins=origins, @@ -49,3 +49,6 @@ app.add_middleware( allow_methods=["*"], allow_headers=["*"], ) + + + diff --git a/items/models.py b/items/models.py index 75215e3..8d7cb69 100644 --- a/items/models.py +++ b/items/models.py @@ -1,15 +1,12 @@ -from datetime import datetime -from ..config import Base -from sqlalchemy import Column, Integer, String, DateTime, ForeignKey -from sqlalchemy.orm import relationship, Mapped, mapped_column +from datetime import datetime, timedelta, timezone +from ..auth.models import UserBase + +class UserProfile(UserBase): + bio : str | None = None + created_date : datetime | None = None + collections : list[str] | None = None + items :list[str] | None = None + + + -class Item(Base): - __tablename__ = "items" - item_id = Column(Integer, primary_key=True) - name = Column(String(100), nullable=False) - description = Column(String(500), nullable=True) - price = Column(Integer, nullable=False) - created_date = Column(DateTime, default=datetime.utcnow) - updated_date = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) - user_id: Mapped[int] = mapped_column(ForeignKey("users.id")) - user: Mapped["User"] = relationship(back_populates="items") \ No newline at end of file diff --git a/items/router.py b/items/router.py index 2961d4f..7fd3c4b 100644 --- a/items/router.py +++ b/items/router.py @@ -1,4 +1,7 @@ +from .models import UserProfile from fastapi import APIRouter, Depends +from typing import Annotated +from ..auth.models import get_current_active_user router = APIRouter( prefix="/items", @@ -7,7 +10,9 @@ router = APIRouter( dependencies=[], ) - -@router.get("/") -async def get_items(): - return {"message": "List of items"} \ No newline at end of file +@router.get('/profile', response_model=UserProfile) +async def get_user_profile( + current_user: Annotated[UserProfile, Depends(get_current_active_user)] +) -> UserProfile: + + return current_user \ No newline at end of file From 36da53a5620566b9977f50923690e84f0d76cac1 Mon Sep 17 00:00:00 2001 From: bdrtr Date: Tue, 6 May 2025 14:06:15 +0300 Subject: [PATCH 2/8] base model --- auth/models.py | 108 ++++++++++++++++++++++++++++++++--------------- auth/router.py | 26 +++--------- config.py | 37 ++++++++++------ requirements.txt | 3 ++ 4 files changed, 105 insertions(+), 69 deletions(-) diff --git a/auth/models.py b/auth/models.py index 7a3dd73..e2786b7 100644 --- a/auth/models.py +++ b/auth/models.py @@ -1,15 +1,14 @@ from enum import Enum -from backend.config import SECRET_KEY, ALGORITHM, ACCESS_TOKEN_EXPIRE_MINUTES -from backend.config import pwd_context, get_session_db +from backend.config import SECRET_KEY, ALGORITHM, ACCESS_TOKEN_EXPIRE_MINUTES ,pwd_context, get_session_db, Base from datetime import datetime, timedelta, timezone from pydantic import BaseModel from fastapi import Depends, HTTPException -from typing import Annotated, Optional +from typing import Annotated from fastapi.security import OAuth2PasswordBearer -from passlib.context import CryptContext -import jwt -from sqlmodel import SQLModel, Field, Session, select from pydantic.networks import EmailStr +from sqlalchemy import Column, Integer, String +from sqlalchemy.orm import Session +import jwt class Token(BaseModel): access_token: str @@ -28,40 +27,49 @@ class Status(str, Enum): banned = "banned" suspended = "suspended" -### KULLANICI MODELLERİ ### -class UserBase(SQLModel): - username: Optional[str] = None - user_id: Optional[int] = None - role: Optional[Role] = None - status: Optional[Status] = None +### KULLANICI MODELLERİ ### sqlalchemy ve pydantic modelleri farklıdır +class UserBase(BaseModel): #bu bir veri tabanı modeli değil !!!! lütfen dikkat et + username: str | None = None #Option yerine Union kullanabilirsin + role: Role | None = None + status: Status | None = None class UserInDb(UserBase): + user_id: int | None = None + email: EmailStr | None = None hashed_password: str | None = None -class UserPublic(UserBase): - pass +class UserPublic(BaseModel): + username : str | None = None + role : Role | None = None + status : Status | None = None class UserCreate(BaseModel): - username: Optional[str] = None - role: Optional[Role] = None + username: str | None = None + role: Role | None = None email : EmailStr | None = None - status: Optional[Status] = None + status: Status | None = None password : str | None = None ### VERİTABANI MODELİ ### -class DBUser(SQLModel, table=True): - __tablename__ = "users" # opsiyonel, sqlmodel bunu otomatik de atar - user_id: Optional[int] = Field(default=None, primary_key=True) - username: str = Field(index=True, nullable=False) - hashed_password: str = Field(nullable=False) - role: Role = Field(default=Role.user) - status: Status = Field(default=Status.active) +class DBUser(Base): + __tablename__ = "users_table" + + user_id = Column(Integer, primary_key=True, index=True) + username = Column(String, unique=True, index=True, nullable=False) + email = Column(String, unique=True, index=True, nullable=False) + hashed_password = Column(String, nullable=False) + role = Column(String, default="user") + status = Column(String, default="active") + created_date = Column(String, default=datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")) ### AUTH ### oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login") + +### SERVİSLER ### + def verify_password(plain_password: str, hashed_password: str) -> bool: return pwd_context.verify(plain_password, hashed_password) @@ -74,21 +82,20 @@ def authenticate_user( password: str ) -> UserInDb | None: - statement = select(DBUser).where(DBUser.username == username) - result = session.exec(statement).first() - if not result or not verify_password(password, result.hashed_password): + user = session.query(DBUser).filter(DBUser.username == username).first() + if user is None or not verify_password(password, user.hashed_password): #sqlalchemy'de bu şekilde kontrol ediliyor None ile return None - return result + return user def create_access_token( data: dict, - expires_delta: Optional[timedelta] = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES), + expires_delta: Annotated[timedelta, None] = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES), ) -> str: to_encode = data.copy() expire = datetime.now(timezone.utc) + expires_delta to_encode.update({"exp": expire}) - encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm="HS256") + encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM) return encoded_jwt @@ -97,9 +104,8 @@ async def get_user( username: str ) -> UserInDb | None: - statement = select(DBUser).where(DBUser.username == username) - result = session.exec(statement).first() - return result + user = session.query(DBUser).filter(DBUser.username == username).first() + return user async def get_current_user( @@ -113,10 +119,13 @@ async def get_current_user( headers={"WWW-Authenticate": "Bearer"}, ) try: - payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"]) - username: Optional[str] = payload.get("sub") + payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM]) + username : str | None = payload.get("sub") + user = UserInDb.model_validate(payload) + if username is None: raise credentials_exception + except jwt.PyJWTError: raise credentials_exception @@ -133,3 +142,32 @@ async def get_current_active_user( if current_user.status == Status.banned: raise HTTPException(status_code=400, detail="Inactive user") return current_user + + +### Kullanıcı kaydı +def register_user( + session: Annotated[Session, Depends(get_session_db)], + user: Annotated[UserCreate, Depends()] +) -> UserPublic: + + user_dict = user.dict() # kullanıcıdan gelen verileri alıyoruz çunku şifreyi hashleyeceğiz + user_dict['hashed_password'] = get_password_hash(user.password) # şifreyi hashliyoruz + + if not verify_password(user.password, user_dict['hashed_password']): + raise HTTPException(status_code=400, detail="Password hashing failed") # şifre hashleme işlemi başarısız oldu + + # Kullanıcı adı ve e-posta adresinin benzersiz olduğunu kontrol et + existing_user = session.query(DBUser).filter( + (DBUser.username == user.username) | (DBUser.email == user.email) + ).first() + + if existing_user: + raise HTTPException(status_code=400, detail="Username or email already registered") + + user_dict['created_date'] = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S") # kullanıcı oluşturulma tarihi + user_dict.pop('password') ##password'u veri tabanına eklemiyoruz zaten sınıfımızda tanımlı değil hata verir + db_user = DBUser(**user_dict) #alchemy ile pydantic modelleri farklıdır bir birine + session.add(db_user) # donuşum yaparken dikkat et + session.commit() + session.refresh(db_user) + return db_user \ No newline at end of file diff --git a/auth/router.py b/auth/router.py index 0b8517e..afd4416 100644 --- a/auth/router.py +++ b/auth/router.py @@ -1,15 +1,10 @@ from fastapi import APIRouter, Depends, HTTPException, status -from .models import Token, UserPublic -from .models import authenticate_user, create_access_token +from .models import Token, UserPublic, authenticate_user, create_access_token, UserCreate, register_user from datetime import timedelta -from ..auth.models import get_password_hash, verify_password from typing import Annotated -from sqlmodel import Session from ..config import get_session_db -from fastapi import Depends from fastapi.security import OAuth2PasswordRequestForm -from .models import UserCreate, DBUser - +from sqlalchemy.orm import Session router = APIRouter( prefix="/auth", @@ -38,21 +33,12 @@ async def login_for_access_token( return Token(access_token=access_token, token_type="bearer") -@router.post('/register', response_model=UserPublic) +@router.post('/register', response_model=UserPublic) #userPublic güvenli bir model async def create_user( session : Annotated[Session, Depends(get_session_db)], user : Annotated[UserCreate, Depends()] ): - user_dict = user.dict() - print(user.password) - user_dict['hashed_password'] = get_password_hash(user.password) - print (user_dict['hashed_password']) + + return register_user(session, user) - if not verify_password(user.password, user_dict['hashed_password']): - raise HTTPException(status_code=400, detail="Password hashing failed") - - db_user = DBUser.model_validate(user_dict) - session.add(db_user) - session.commit() - session.refresh(db_user) - return db_user \ No newline at end of file + \ No newline at end of file diff --git a/config.py b/config.py index 07d6e59..48997bd 100644 --- a/config.py +++ b/config.py @@ -4,29 +4,38 @@ from sqlalchemy.orm import sessionmaker from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from passlib.context import CryptContext -from sqlmodel import SQLModel, Field, Session from dotenv import load_dotenv import os load_dotenv() -# Veritabanı URL'sini oluştur -DATABASE_URL = ( - f"postgresql://{os.getenv('USERNAME_DB')}:" - f"{os.getenv('PASSWORD_DB')}@" - f"{os.getenv('HOST_DB')}:" - f"{os.getenv('PORT_DB')}/" - f"{os.getenv('NAME_DB')}" -) +pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto") +SECRET_KEY = os.getenv("SECRET_KEY") +ALGORITHM = os.getenv("ALGORITHM") +ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", 30)) + +DATABASE_URL = os.getenv("DATABASE_URL") +# Engine oluştur engine = create_engine(DATABASE_URL, echo=False) -def init_db(): - SQLModel.metadata.create_all(engine) +# Session factory oluştur +SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) +Base = declarative_base() #sqlalchemy için bu sınıfı kullanıyoruz 'class DBUser(Base)' şeklinde tanımlıyoruz +#models te içe aktarmayı unutma +def init_db(): + Base.metadata.drop_all(engine) # Veritabanını her başlangıcta siler burayada dikkat !!!!!!!! + Base.metadata.create_all(bind=engine) + +# Session dependency (FastAPI için) def get_session_db(): - with Session(engine) as session: - yield session + db = SessionLocal() + try: + yield db + finally: + db.close() + ### SECRET KEY ### @@ -39,7 +48,7 @@ origins = [ app = FastAPI() @app.on_event("startup") -def on_startup(): +def startup_event(): init_db() app.add_middleware( diff --git a/requirements.txt b/requirements.txt index 3f98454..0f102cc 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,6 @@ annotated-types==0.7.0 anyio==4.9.0 +bcrypt==4.3.0 certifi==2025.4.26 click==8.1.8 dnspython==2.7.0 @@ -39,3 +40,5 @@ uvicorn==0.34.2 uvloop==0.21.0 watchfiles==1.0.5 websockets==15.0.1 +passlib[bcrypt]==1.7.4 + From 842c12781733887bce4cd2ceb8cbddf04aa574fb Mon Sep 17 00:00:00 2001 From: bdrtr Date: Wed, 7 May 2025 18:33:35 +0300 Subject: [PATCH 3/8] user process --- auth/models.py | 69 +++++++++++++++++++++++++++++++++++++++++++++++++- auth/router.py | 35 +++++++++++++++++++++++-- 2 files changed, 101 insertions(+), 3 deletions(-) diff --git a/auth/models.py b/auth/models.py index e2786b7..fb259fd 100644 --- a/auth/models.py +++ b/auth/models.py @@ -1,4 +1,6 @@ from enum import Enum +import random +import smtplib from backend.config import SECRET_KEY, ALGORITHM, ACCESS_TOKEN_EXPIRE_MINUTES ,pwd_context, get_session_db, Base from datetime import datetime, timedelta, timezone from pydantic import BaseModel @@ -8,6 +10,7 @@ from fastapi.security import OAuth2PasswordBearer from pydantic.networks import EmailStr from sqlalchemy import Column, Integer, String from sqlalchemy.orm import Session +from email.message import EmailMessage import jwt class Token(BaseModel): @@ -170,4 +173,68 @@ def register_user( session.add(db_user) # donuşum yaparken dikkat et session.commit() session.refresh(db_user) - return db_user \ No newline at end of file + return db_user + + +def find_user_w_email( + session: Annotated[Session, Depends(get_session_db)], + email: EmailStr | None = None, +): + + exist_user = session.query(DBUser).filter(DBUser.email == email).first() #email ile kullanıcıyı bul + if exist_user is None: + raise HTTPException(status_code=400, detail="User not found") + + if exist_user.status == Status.banned: + raise HTTPException(status_code=400, detail="Inactive user") + + return True + +def send_password_to_email( + session: Annotated[Session, Depends(get_session_db)], + email: EmailStr | None = None, +) -> str: + + msg = EmailMessage() #obje oluştur + msg['Subject'] = 'Password Reset' + msg['From'] = 'hansneiumann@gmail.com' + msg['To'] = email + veritification_code = generate_password_reset_number() + msg.set_content(veritification_code) + + with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp: + smtp.login("hansneiumann@gmail.com", "rwaq mbil lzut dgja") + smtp.send_message(msg) + + update_password_w_email(session, email=email, password=veritification_code) #şifreyi güncelle + + +def generate_password_reset_number() -> str: + return str(random.randint(10000000, 99999999)) # 8 haneli rastgele bir sayı döndür + + +def update_password_w_email( + session: Annotated[Session, Depends(get_session_db)], + password: str | None = None, + email: EmailStr | None = None, +) -> dict: + + hashed_password = get_password_hash(password) + session.query(DBUser).filter(DBUser.email == email).update({"hashed_password": hashed_password}) + session.commit() + + return {"message": "Password updated successfully"} + +def update_password_w_user( + session: Annotated[Session, Depends(get_session_db)], + user: Annotated[DBUser , None], + password: str | None = None, + +): + + hashed_password = get_password_hash(password) + session.query(DBUser).filter(DBUser.user_id == user.user_id).update({"hashed_password": hashed_password}) + session.commit() + session.refresh(user) + + \ No newline at end of file diff --git a/auth/router.py b/auth/router.py index afd4416..7b09a33 100644 --- a/auth/router.py +++ b/auth/router.py @@ -1,10 +1,12 @@ -from fastapi import APIRouter, Depends, HTTPException, status -from .models import Token, UserPublic, authenticate_user, create_access_token, UserCreate, register_user +from fastapi import APIRouter, Depends, HTTPException, status, BackgroundTasks +from .models import Token, UserPublic, authenticate_user, create_access_token, UserCreate, find_user_w_email, get_current_user, register_user, send_password_to_email, update_password_w_user from datetime import timedelta from typing import Annotated from ..config import get_session_db from fastapi.security import OAuth2PasswordRequestForm from sqlalchemy.orm import Session +from pydantic.networks import EmailStr + router = APIRouter( prefix="/auth", @@ -41,4 +43,33 @@ async def create_user( return register_user(session, user) +@router.post('/password_reset') +async def password_reset( + session : Annotated[Session, Depends(get_session_db)], + email : Annotated[EmailStr, None] = None, + task: Annotated[BackgroundTasks, None] = None, # BackgroundTasks, task'ı arka planda çalıştırmak için kullanıyoruz +): + + if not find_user_w_email(session, email): + return HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="bad request", + ) + + task.add_task(send_password_to_email, session, email) + + return {"message": "New password has been sent to your email."} + +@router.post('/update_password') +async def update_password( + user: Annotated[str, Depends(get_current_user)], + session: Annotated[Session, Depends(get_session_db)], + new_password: Annotated[str, None] = None, +) -> dict: + + update_password_w_user(session, user, new_password) + + return {"message": "Password updated successfully."} + + \ No newline at end of file From 938f950646a07d9672a32f05f88e03ec95cdeaca Mon Sep 17 00:00:00 2001 From: bdrtr Date: Wed, 7 May 2025 20:15:51 +0300 Subject: [PATCH 4/8] generated _collections class --- _collections/models.py | 18 ++++++++++++ _collections/router.py | 8 +++++ auth/models.py | 9 ++++-- items/models.py | 66 +++++++++++++++++++++++++++++++++++++++--- items/router.py | 42 +++++++++++++++++++++++---- main.py | 2 ++ 6 files changed, 132 insertions(+), 13 deletions(-) create mode 100644 _collections/models.py create mode 100644 _collections/router.py diff --git a/_collections/models.py b/_collections/models.py new file mode 100644 index 0000000..760d5d6 --- /dev/null +++ b/_collections/models.py @@ -0,0 +1,18 @@ +from fastapi import HTTPException +from sqlalchemy import Column, Integer, String, Float, Boolean, ForeignKey +from sqlalchemy.dialects.postgresql import ARRAY +from sqlalchemy.orm import Session +from ..config import Base + + + + +##### veri tabanı modelleri ##### +class Collections(Base): + __tablename__ = "collections_table" + + collection_id = Column(Integer, index=True, primary_key=True , autoincrement=True) + user_id = Column(Integer, ForeignKey('users_table.user_id'), nullable=False) + visibility = Column(Boolean, default=True) + colllection_name = Column(String, default="No name") + collection_description = Column(String, default="No description") \ No newline at end of file diff --git a/_collections/router.py b/_collections/router.py new file mode 100644 index 0000000..72387ea --- /dev/null +++ b/_collections/router.py @@ -0,0 +1,8 @@ +from fastapi import FastAPI, APIRouter + +router = APIRouter( + prefix="/collections", + tags=["collections"], + responses={404: {"description": "Not found"}}, + dependencies=[], +) \ No newline at end of file diff --git a/auth/models.py b/auth/models.py index fb259fd..a686151 100644 --- a/auth/models.py +++ b/auth/models.py @@ -10,6 +10,7 @@ from fastapi.security import OAuth2PasswordBearer from pydantic.networks import EmailStr from sqlalchemy import Column, Integer, String from sqlalchemy.orm import Session +from sqlalchemy.dialects.postgresql import ARRAY from email.message import EmailMessage import jwt @@ -53,6 +54,7 @@ class UserCreate(BaseModel): status: Status | None = None password : str | None = None + ### VERİTABANI MODELİ ### class DBUser(Base): __tablename__ = "users_table" @@ -64,6 +66,9 @@ class DBUser(Base): role = Column(String, default="user") status = Column(String, default="active") created_date = Column(String, default=datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")) + bio = Column(String, default="No bio") + collections = Column(ARRAY(String), default=['likes']) + follower_user = Column(ARRAY(Integer), default=[]) ### AUTH ### @@ -230,11 +235,9 @@ def update_password_w_user( user: Annotated[DBUser , None], password: str | None = None, -): +) -> any: hashed_password = get_password_hash(password) session.query(DBUser).filter(DBUser.user_id == user.user_id).update({"hashed_password": hashed_password}) session.commit() - session.refresh(user) - \ No newline at end of file diff --git a/items/models.py b/items/models.py index 8d7cb69..f1c70c4 100644 --- a/items/models.py +++ b/items/models.py @@ -1,11 +1,69 @@ from datetime import datetime, timedelta, timezone -from ..auth.models import UserBase +from typing import Annotated +from pydantic import BaseModel +from fastapi import Depends +from sqlalchemy.orm import Session +from sqlalchemy import ForeignKey, Column, Integer, String, Float +from sqlalchemy.dialects.postgresql import ARRAY +from ..auth.models import DBUser, Role, Status, UserBase +from ..config import Base, get_session_db -class UserProfile(UserBase): +class UserProfileBase(UserBase): bio : str | None = None created_date : datetime | None = None - collections : list[str] | None = None - items :list[str] | None = None + # collection : list[str] | None = None + +class UserProfileID(UserProfileBase): + user_id : int | None = None + + +class UserProfilePublic(UserProfileBase): + pass + +class UserProfilePrivate(UserProfilePublic): + collection : list[str] | None = None + role : Role | None = None + status : Status | None = None + follow_user : list[int] | None = None + +##### VERİTABANI MODELİ ##### +# Tüm modeller AUTH'da veri tabanına işlendi yukardaki +#modeller veri tabanında mevcuttur. Değiştirmek için AUTH'daki +# DBUser modelini değiştirip tekrar veri tabanına işleyebilirsin + +class Items(Base): + __tablename__ = "items_table" + + item_id = Column(Integer, primary_key=True, index=True) + user_id = Column(Integer, ForeignKey("users_table.user_id"), nullable=False) + #collection_id = Column(Integer, ForeignKey("collections_table.collection_id"), nullable=False) + item_created_date = Column(String, default=datetime.now()) + item_location = Column(String, default="No location") #daha net tanımlancak + item_type = Column(String, default="No type") + item_content = Column(String, default="No content") + item_score = Column(Float, default=0.0) + + + + +def is_user_exsist(username : str, session : Annotated[Session, Depends(get_session_db)]) -> bool | UserProfilePublic: + #DBUser veritabanındaki nesnedir her niteliğe sahiptir + user = session.query(DBUser).filter(DBUser.username == username).first() + return user + + +def all_users(session: Annotated[Session, Depends(get_session_db)]) -> list[UserProfilePublic]: + users = session.query(DBUser).all() + + return [UserProfilePublic( + username=user.username, + bio=user.bio, + created_date=user.created_date, + items=user.items, + collections=user.collections, + role=user.role, + status=user.status + ) for user in users] diff --git a/items/router.py b/items/router.py index 7fd3c4b..d67b90c 100644 --- a/items/router.py +++ b/items/router.py @@ -1,5 +1,7 @@ -from .models import UserProfile +from .models import UserProfileBase, UserProfileID, UserProfilePrivate, UserProfilePublic, all_users, is_user_exsist from fastapi import APIRouter, Depends +from sqlalchemy.orm import Session +from ..config import get_session_db from typing import Annotated from ..auth.models import get_current_active_user @@ -10,9 +12,37 @@ router = APIRouter( dependencies=[], ) -@router.get('/profile', response_model=UserProfile) -async def get_user_profile( - current_user: Annotated[UserProfile, Depends(get_current_active_user)] -) -> UserProfile: +@router.get('/all_profiles') +async def get_user_profile(session: Annotated[Session, Depends(get_session_db)]) -> list[UserProfilePublic]: - return current_user \ No newline at end of file + return all_users(session=session) + + +@router.get('/profile/{username}') +async def get_user_profile_by_username( + username: str, + session: Annotated[Session, Depends(get_session_db)], +) -> UserProfilePublic | dict: + + user : UserProfilePublic = is_user_exsist(username, session) + if user is None: + return {"error": "User not found"} + + return user + +@router.get('/profile/me') +async def get_user_profile_me( + current_user: Annotated[UserProfilePrivate, Depends(get_current_active_user)] #dependtek kaynaklı UserPublic doner + ) -> UserProfilePrivate: + + return current_user + + +@router.post('/create') +async def create_user_profile( + user : Annotated[UserProfileID, Depends(get_current_active_user)], + session: Annotated[Session, Depends(get_session_db)], +) -> UserProfileBase: + + return user + \ No newline at end of file diff --git a/main.py b/main.py index 14bc3fd..93010c6 100644 --- a/main.py +++ b/main.py @@ -1,6 +1,8 @@ from .config import app from .auth.router import router as auth_router from .items.router import router as items_router +from ._collections.router import router as collections_router app.include_router(auth_router) +app.include_router(collections_router) app.include_router(items_router) From 7c35097c8892be4f14c2ef2577dddc6f49012950 Mon Sep 17 00:00:00 2001 From: bdrtr Date: Thu, 8 May 2025 19:58:41 +0300 Subject: [PATCH 5/8] items-models-import-error --- _collections/models.py | 11 +++++--- auth/models.py | 29 +++++++++++--------- config.py | 12 ++++++--- items/models.py | 61 +++++++++++++++++++++++++++++++++++------- items/router.py | 13 ++++++--- 5 files changed, 94 insertions(+), 32 deletions(-) diff --git a/_collections/models.py b/_collections/models.py index 760d5d6..5cd6efa 100644 --- a/_collections/models.py +++ b/_collections/models.py @@ -1,12 +1,12 @@ from fastapi import HTTPException from sqlalchemy import Column, Integer, String, Float, Boolean, ForeignKey from sqlalchemy.dialects.postgresql import ARRAY -from sqlalchemy.orm import Session +from sqlalchemy.orm import Session, relationship from ..config import Base - +''' ##### veri tabanı modelleri ##### class Collections(Base): __tablename__ = "collections_table" @@ -15,4 +15,9 @@ class Collections(Base): user_id = Column(Integer, ForeignKey('users_table.user_id'), nullable=False) visibility = Column(Boolean, default=True) colllection_name = Column(String, default="No name") - collection_description = Column(String, default="No description") \ No newline at end of file + collection_description = Column(String, default="No description") + + # ilişkiler + user = relationship("DBUser", back_populates="user_collections") + items = relationship("Items", back_populates="collection", cascade="all, delete-orphan") +''' \ No newline at end of file diff --git a/auth/models.py b/auth/models.py index a686151..6305dcc 100644 --- a/auth/models.py +++ b/auth/models.py @@ -8,10 +8,11 @@ from fastapi import Depends, HTTPException from typing import Annotated from fastapi.security import OAuth2PasswordBearer from pydantic.networks import EmailStr -from sqlalchemy import Column, Integer, String -from sqlalchemy.orm import Session +from sqlalchemy import Integer, DateTime +from sqlalchemy.orm import Session, relationship, mapped_column, Mapped from sqlalchemy.dialects.postgresql import ARRAY from email.message import EmailMessage + import jwt class Token(BaseModel): @@ -59,16 +60,20 @@ class UserCreate(BaseModel): class DBUser(Base): __tablename__ = "users_table" - user_id = Column(Integer, primary_key=True, index=True) - username = Column(String, unique=True, index=True, nullable=False) - email = Column(String, unique=True, index=True, nullable=False) - hashed_password = Column(String, nullable=False) - role = Column(String, default="user") - status = Column(String, default="active") - created_date = Column(String, default=datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")) - bio = Column(String, default="No bio") - collections = Column(ARRAY(String), default=['likes']) - follower_user = Column(ARRAY(Integer), default=[]) + user_id: Mapped[int] = mapped_column(primary_key=True, index=True, autoincrement=True) + username : Mapped[str] = mapped_column(unique=True, index=True, nullable=False) + email : Mapped[str] = mapped_column(unique=True, index=True, nullable=False) + hashed_password : Mapped[str] = mapped_column(nullable=False) + role : Mapped[Role] = mapped_column(default=Role.user) + status : Mapped[Status] = mapped_column(default=Status.active) + created_date : Mapped[datetime] = mapped_column(DateTime, default=datetime.now()) #datetime.datetime -> python, DateTime -> sqlalchemy + bio : Mapped[str] = mapped_column(default="No bio") + follow_users : Mapped[list[int]] = mapped_column(ARRAY(Integer), default=[]) # takip edilen kullanıcılar + + # -> buralar diğer tablolar ile olan ilişkiler + from ..items.models import Items + items : Mapped[list['Items']] = relationship("Items", back_populates="user", cascade="all, delete-orphan", lazy='select') + ### AUTH ### diff --git a/config.py b/config.py index 48997bd..40dc1d9 100644 --- a/config.py +++ b/config.py @@ -1,6 +1,5 @@ from sqlalchemy import create_engine -from sqlalchemy.ext.declarative import declarative_base -from sqlalchemy.orm import sessionmaker +from sqlalchemy.orm import sessionmaker, DeclarativeBase from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from passlib.context import CryptContext @@ -21,11 +20,16 @@ DATABASE_URL = os.getenv("DATABASE_URL") engine = create_engine(DATABASE_URL, echo=False) # Session factory oluştur SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) -Base = declarative_base() #sqlalchemy için bu sınıfı kullanıyoruz 'class DBUser(Base)' şeklinde tanımlıyoruz +#Base = declarative_base() #sqlalchemy için bu sınıfı kullanıyoruz 'class DBUser(Base)' şeklinde tanımlıyoruz + +class Base(DeclarativeBase): + pass #yeni sqlalchemy sürümünde bu sınıfı kullanıyoruz + + #models te içe aktarmayı unutma def init_db(): - Base.metadata.drop_all(engine) # Veritabanını her başlangıcta siler burayada dikkat !!!!!!!! + #Base.metadata.drop_all(engine) # Veritabanını her başlangıcta siler burayada dikkat !!!!!!!! Base.metadata.create_all(bind=engine) # Session dependency (FastAPI için) diff --git a/items/models.py b/items/models.py index f1c70c4..220ba7d 100644 --- a/items/models.py +++ b/items/models.py @@ -1,12 +1,19 @@ from datetime import datetime, timedelta, timezone from typing import Annotated + +from sqlalchemy import DateTime from pydantic import BaseModel from fastapi import Depends -from sqlalchemy.orm import Session +from sqlalchemy.orm import Session, relationship, mapped_column, Mapped from sqlalchemy import ForeignKey, Column, Integer, String, Float from sqlalchemy.dialects.postgresql import ARRAY -from ..auth.models import DBUser, Role, Status, UserBase from ..config import Base, get_session_db +from typing import TYPE_CHECKING +from ..auth.models import Role, Status, UserBase + +####!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +from ..auth.models import DBUser # -> tam burda bir hata var circle import yaparken karışıyor nasıl çözülecek bilmiyorum + class UserProfileBase(UserBase): bio : str | None = None @@ -26,26 +33,44 @@ class UserProfilePrivate(UserProfilePublic): status : Status | None = None follow_user : list[int] | None = None + + +######## ITEMS ###### + +class BaseItem(BaseModel): + item_created_date : datetime | None = None + item_location : str | None = None + item_type : str | None = None + item_content : str | None = None + +class ItemCreate(BaseItem): # item oluşturma için ekstra bir ihtiyaci olmaz + pass + ##### VERİTABANI MODELİ ##### # Tüm modeller AUTH'da veri tabanına işlendi yukardaki #modeller veri tabanında mevcuttur. Değiştirmek için AUTH'daki # DBUser modelini değiştirip tekrar veri tabanına işleyebilirsin - +''' +''' class Items(Base): __tablename__ = "items_table" - item_id = Column(Integer, primary_key=True, index=True) - user_id = Column(Integer, ForeignKey("users_table.user_id"), nullable=False) - #collection_id = Column(Integer, ForeignKey("collections_table.collection_id"), nullable=False) - item_created_date = Column(String, default=datetime.now()) - item_location = Column(String, default="No location") #daha net tanımlancak + item_id : Mapped[int] = mapped_column(primary_key=True, index=True, autoincrement=True) + user_id : Mapped[int] = mapped_column(ForeignKey('users_table.user_id'), nullable=False, index=True) + item_created_date : Mapped[datetime] = mapped_column(DateTime, default=datetime.now()) + item_location = Column(String, default="No location") item_type = Column(String, default="No type") item_content = Column(String, default="No content") item_score = Column(Float, default=0.0) + + # ilişkiler + + user : Mapped['DBUser'] = relationship("DBUser", back_populates="items", lazy='select') + #collection = relationship("Collections", back_populates="items") - - +''' +''' def is_user_exsist(username : str, session : Annotated[Session, Depends(get_session_db)]) -> bool | UserProfilePublic: #DBUser veritabanındaki nesnedir her niteliğe sahiptir user = session.query(DBUser).filter(DBUser.username == username).first() @@ -66,5 +91,21 @@ def all_users(session: Annotated[Session, Depends(get_session_db)]) -> list[User ) for user in users] +def add_Item_user( + user: Annotated[UserProfileID, Depends(get_session_db)], + session: Annotated[Session, Depends(get_session_db)], + item: ItemCreate) -> bool: + # DBUser veritabanındaki nesnedir her niteliğe sahiptir + item = Items( + user_id=user.user_id, + item_location=item.item_location, + item_type=item.item_type, + item_content=item.item_content, + item_score=item.item_score, + item_created_date=item.item_created_date + ) + session.add(item) + session.commit() + return True diff --git a/items/router.py b/items/router.py index d67b90c..f2e4718 100644 --- a/items/router.py +++ b/items/router.py @@ -1,4 +1,4 @@ -from .models import UserProfileBase, UserProfileID, UserProfilePrivate, UserProfilePublic, all_users, is_user_exsist +from .models import ItemCreate, UserProfileBase, UserProfileID, UserProfilePrivate, UserProfilePublic, add_Item_user, all_users, is_user_exsist from fastapi import APIRouter, Depends from sqlalchemy.orm import Session from ..config import get_session_db @@ -42,7 +42,14 @@ async def get_user_profile_me( async def create_user_profile( user : Annotated[UserProfileID, Depends(get_current_active_user)], session: Annotated[Session, Depends(get_session_db)], -) -> UserProfileBase: + item : Annotated[ItemCreate , None] = None +) -> dict: - return user + if add_Item_user(user, session, item) : + return {"message": "User item created successfully"} + + return {"error": "User item creation failed"} + + + \ No newline at end of file From 039b8772419ac5efc6bd42bf4c4583edd0760905 Mon Sep 17 00:00:00 2001 From: bdrtr Date: Thu, 8 May 2025 22:43:42 +0300 Subject: [PATCH 6/8] item-create --- auth/models.py | 12 ++++++++---- config.py | 2 +- items/models.py | 27 ++++++++++++++++----------- items/router.py | 11 ++++++----- 4 files changed, 31 insertions(+), 21 deletions(-) diff --git a/auth/models.py b/auth/models.py index 6305dcc..d231622 100644 --- a/auth/models.py +++ b/auth/models.py @@ -12,6 +12,11 @@ from sqlalchemy import Integer, DateTime from sqlalchemy.orm import Session, relationship, mapped_column, Mapped from sqlalchemy.dialects.postgresql import ARRAY from email.message import EmailMessage +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ..items.models import Items + import jwt @@ -69,10 +74,9 @@ class DBUser(Base): created_date : Mapped[datetime] = mapped_column(DateTime, default=datetime.now()) #datetime.datetime -> python, DateTime -> sqlalchemy bio : Mapped[str] = mapped_column(default="No bio") follow_users : Mapped[list[int]] = mapped_column(ARRAY(Integer), default=[]) # takip edilen kullanıcılar - # -> buralar diğer tablolar ile olan ilişkiler - from ..items.models import Items - items : Mapped[list['Items']] = relationship("Items", back_populates="user", cascade="all, delete-orphan", lazy='select') + items : Mapped[list['Items']] = relationship("Items", back_populates="user", cascade="all, delete-orphan") + collections : Mapped[int] = mapped_column(default=0) # hat vermesin diye eklendi collections aktif değil @@ -128,7 +132,7 @@ async def get_current_user( credentials_exception = HTTPException( status_code=401, - detail="Invalid credentials", + detail="Invalid credentials currently", headers={"WWW-Authenticate": "Bearer"}, ) try: diff --git a/config.py b/config.py index 40dc1d9..7137b4c 100644 --- a/config.py +++ b/config.py @@ -30,7 +30,7 @@ class Base(DeclarativeBase): def init_db(): #Base.metadata.drop_all(engine) # Veritabanını her başlangıcta siler burayada dikkat !!!!!!!! - Base.metadata.create_all(bind=engine) + Base.metadata.create_all(bind=engine) # Veritabanını oluşturur # Session dependency (FastAPI için) def get_session_db(): diff --git a/items/models.py b/items/models.py index 220ba7d..40aec27 100644 --- a/items/models.py +++ b/items/models.py @@ -1,6 +1,5 @@ from datetime import datetime, timedelta, timezone from typing import Annotated - from sqlalchemy import DateTime from pydantic import BaseModel from fastapi import Depends @@ -9,10 +8,7 @@ from sqlalchemy import ForeignKey, Column, Integer, String, Float from sqlalchemy.dialects.postgresql import ARRAY from ..config import Base, get_session_db from typing import TYPE_CHECKING -from ..auth.models import Role, Status, UserBase - -####!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! -from ..auth.models import DBUser # -> tam burda bir hata var circle import yaparken karışıyor nasıl çözülecek bilmiyorum +from ..auth.models import Role, Status, UserBase, DBUser class UserProfileBase(UserBase): @@ -28,10 +24,11 @@ class UserProfilePublic(UserProfileBase): pass class UserProfilePrivate(UserProfilePublic): - collection : list[str] | None = None + #collection : list[str] | None = None role : Role | None = None status : Status | None = None follow_user : list[int] | None = None + items : list['Item'] | None = None @@ -46,6 +43,15 @@ class BaseItem(BaseModel): class ItemCreate(BaseItem): # item oluşturma için ekstra bir ihtiyaci olmaz pass + +class Item(BaseItem): + item_id : int | None = None + user_id : int | None = None + item_score : float | None = None + + class Config: + from_attributes = True #sqlalchemy ile pydantic arasında geçiş yapabilmek için kullanılır + ##### VERİTABANI MODELİ ##### # Tüm modeller AUTH'da veri tabanına işlendi yukardaki #modeller veri tabanında mevcuttur. Değiştirmek için AUTH'daki @@ -71,20 +77,20 @@ class Items(Base): ''' ''' -def is_user_exsist(username : str, session : Annotated[Session, Depends(get_session_db)]) -> bool | UserProfilePublic: +def is_user_exsist_get(username : str, session : Annotated[Session, Depends(get_session_db)]) -> bool | UserProfilePrivate: #DBUser veritabanındaki nesnedir her niteliğe sahiptir user = session.query(DBUser).filter(DBUser.username == username).first() return user -def all_users(session: Annotated[Session, Depends(get_session_db)]) -> list[UserProfilePublic]: +def all_users(session: Annotated[Session, Depends(get_session_db)]) -> list[UserProfilePrivate]: users = session.query(DBUser).all() - return [UserProfilePublic( + return [UserProfilePrivate( username=user.username, bio=user.bio, created_date=user.created_date, - items=user.items, + items = [Item.model_validate(item) for item in user.items], collections=user.collections, role=user.role, status=user.status @@ -102,7 +108,6 @@ def add_Item_user( item_location=item.item_location, item_type=item.item_type, item_content=item.item_content, - item_score=item.item_score, item_created_date=item.item_created_date ) diff --git a/items/router.py b/items/router.py index f2e4718..d570b30 100644 --- a/items/router.py +++ b/items/router.py @@ -1,4 +1,4 @@ -from .models import ItemCreate, UserProfileBase, UserProfileID, UserProfilePrivate, UserProfilePublic, add_Item_user, all_users, is_user_exsist +from .models import ItemCreate, UserProfileBase, UserProfileID, UserProfilePrivate, UserProfilePublic, add_Item_user, all_users, is_user_exsist_get from fastapi import APIRouter, Depends from sqlalchemy.orm import Session from ..config import get_session_db @@ -13,7 +13,7 @@ router = APIRouter( ) @router.get('/all_profiles') -async def get_user_profile(session: Annotated[Session, Depends(get_session_db)]) -> list[UserProfilePublic]: +async def get_user_profile(session: Annotated[Session, Depends(get_session_db)]) -> list[UserProfilePrivate]: return all_users(session=session) @@ -24,7 +24,7 @@ async def get_user_profile_by_username( session: Annotated[Session, Depends(get_session_db)], ) -> UserProfilePublic | dict: - user : UserProfilePublic = is_user_exsist(username, session) + user : UserProfilePublic = is_user_exsist_get(username, session) if user is None: return {"error": "User not found"} @@ -32,10 +32,11 @@ async def get_user_profile_by_username( @router.get('/profile/me') async def get_user_profile_me( - current_user: Annotated[UserProfilePrivate, Depends(get_current_active_user)] #dependtek kaynaklı UserPublic doner + current_user: Annotated[UserProfilePrivate, Depends(get_current_active_user)], + session : Annotated[Session, Depends(get_session_db)], #dependtek kaynaklı UserPublic doner ) -> UserProfilePrivate: - return current_user + return is_user_exsist_get(current_user.username, session) @router.post('/create') From bf71979982d8acc50cd924071669e8be4fb4e060 Mon Sep 17 00:00:00 2001 From: bdrtr Date: Wed, 14 May 2025 16:31:46 +0300 Subject: [PATCH 7/8] new database system --- _collections/models.py | 23 ------- auth/models.py | 17 ++++-- collectionObj/models.py | 42 +++++++++++++ {_collections => collectionObj}/router.py | 0 config.py | 18 +++++- items/models.py | 73 ++++++----------------- items/router.py | 41 +------------ main.py | 2 +- 8 files changed, 92 insertions(+), 124 deletions(-) delete mode 100644 _collections/models.py create mode 100644 collectionObj/models.py rename {_collections => collectionObj}/router.py (100%) diff --git a/_collections/models.py b/_collections/models.py deleted file mode 100644 index 5cd6efa..0000000 --- a/_collections/models.py +++ /dev/null @@ -1,23 +0,0 @@ -from fastapi import HTTPException -from sqlalchemy import Column, Integer, String, Float, Boolean, ForeignKey -from sqlalchemy.dialects.postgresql import ARRAY -from sqlalchemy.orm import Session, relationship -from ..config import Base - - - -''' -##### veri tabanı modelleri ##### -class Collections(Base): - __tablename__ = "collections_table" - - collection_id = Column(Integer, index=True, primary_key=True , autoincrement=True) - user_id = Column(Integer, ForeignKey('users_table.user_id'), nullable=False) - visibility = Column(Boolean, default=True) - colllection_name = Column(String, default="No name") - collection_description = Column(String, default="No description") - - # ilişkiler - user = relationship("DBUser", back_populates="user_collections") - items = relationship("Items", back_populates="collection", cascade="all, delete-orphan") -''' \ No newline at end of file diff --git a/auth/models.py b/auth/models.py index d231622..d6233ee 100644 --- a/auth/models.py +++ b/auth/models.py @@ -1,21 +1,22 @@ from enum import Enum import random import smtplib -from backend.config import SECRET_KEY, ALGORITHM, ACCESS_TOKEN_EXPIRE_MINUTES ,pwd_context, get_session_db, Base +from backend.config import SECRET_KEY, ALGORITHM, ACCESS_TOKEN_EXPIRE_MINUTES ,pwd_context, get_session_db, Base, user_collection from datetime import datetime, timedelta, timezone from pydantic import BaseModel from fastapi import Depends, HTTPException from typing import Annotated from fastapi.security import OAuth2PasswordBearer from pydantic.networks import EmailStr -from sqlalchemy import Integer, DateTime +from sqlalchemy import Integer, DateTime, ForeignKey from sqlalchemy.orm import Session, relationship, mapped_column, Mapped from sqlalchemy.dialects.postgresql import ARRAY from email.message import EmailMessage from typing import TYPE_CHECKING + if TYPE_CHECKING: - from ..items.models import Items + from ..collectionObj.models import CollectionsDB #iç içe import döngüsünü önlemek için TYPE_CHECKING kullanıyoruz import jwt @@ -66,6 +67,7 @@ class DBUser(Base): __tablename__ = "users_table" user_id: Mapped[int] = mapped_column(primary_key=True, index=True, autoincrement=True) + #collection_id : Mapped[list[int]] = mapped_column(Integer, ForeignKey("collections_table.collection_id"), nullable=True) # collection_id ile ilişki username : Mapped[str] = mapped_column(unique=True, index=True, nullable=False) email : Mapped[str] = mapped_column(unique=True, index=True, nullable=False) hashed_password : Mapped[str] = mapped_column(nullable=False) @@ -75,8 +77,13 @@ class DBUser(Base): bio : Mapped[str] = mapped_column(default="No bio") follow_users : Mapped[list[int]] = mapped_column(ARRAY(Integer), default=[]) # takip edilen kullanıcılar # -> buralar diğer tablolar ile olan ilişkiler - items : Mapped[list['Items']] = relationship("Items", back_populates="user", cascade="all, delete-orphan") - collections : Mapped[int] = mapped_column(default=0) # hat vermesin diye eklendi collections aktif değil + #items : Mapped[list['Items']] = relationship("Items", back_populates="user", cascade="all, delete-orphan") items'e direk değil collection üzerinden erişiyoruz + collections : Mapped[list['CollectionsDB']] = relationship( + "CollectionsDB", + secondary=user_collection, + back_populates="users", + lazy='select' + ) # collection'lar ile olan ilişki diff --git a/collectionObj/models.py b/collectionObj/models.py new file mode 100644 index 0000000..ef6c257 --- /dev/null +++ b/collectionObj/models.py @@ -0,0 +1,42 @@ +from fastapi import HTTPException +from sqlalchemy import Column, Integer, String, Float, Boolean, ForeignKey +from sqlalchemy.dialects.postgresql import ARRAY +from sqlalchemy.orm import Session, relationship, mapped_column, Mapped +from ..config import Base, get_session_db, user_collection, collection_item +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from ..auth.models import DBUser + from ..items.models import Items + + + + +##### veri tabanı modelleri ##### +class CollectionsDB(Base): + __tablename__ = "collections_table" + + collection_id : Mapped[int] = mapped_column(Integer, primary_key=True) + #user_id : Mapped[int] = mapped_column(Integer, ForeignKey("users_table.user_id"), nullable=False) # user_id ile ilişki + #item_id : Mapped[list[int]] = mapped_column(Integer, ForeignKey("items_table.item_id"), nullable=False) # item_id ile ilişki + visibility : Mapped[bool] = mapped_column(Boolean, default=True) + collection_name : Mapped[str] = mapped_column(String, nullable=False) + collection_description : Mapped[str] = mapped_column(String, default="No description") + + # ilişkiler + users : Mapped['DBUser'] = relationship( + "DBUser", + secondary=user_collection, + back_populates="collections", + lazy='select' + ) #back_populates karşı tarafın ismi + + items : Mapped[list['Items']] = relationship( + "Items", + secondary=collection_item, + back_populates="collections" , + lazy='select' + ) + + + #### collection bir item listesi birde kullanıcı listesi tutacak \ No newline at end of file diff --git a/_collections/router.py b/collectionObj/router.py similarity index 100% rename from _collections/router.py rename to collectionObj/router.py diff --git a/config.py b/config.py index 7137b4c..2ab13c7 100644 --- a/config.py +++ b/config.py @@ -2,6 +2,7 @@ from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker, DeclarativeBase from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware +from sqlalchemy import Table, Column, Integer, String, Float, Boolean, ForeignKey from passlib.context import CryptContext from dotenv import load_dotenv import os @@ -29,7 +30,7 @@ class Base(DeclarativeBase): #models te içe aktarmayı unutma def init_db(): - #Base.metadata.drop_all(engine) # Veritabanını her başlangıcta siler burayada dikkat !!!!!!!! + Base.metadata.drop_all(engine) # Veritabanını her başlangıcta siler burayada dikkat !!!!!!!! Base.metadata.create_all(bind=engine) # Veritabanını oluşturur # Session dependency (FastAPI için) @@ -40,6 +41,21 @@ def get_session_db(): finally: db.close() +user_collection = Table( # user -> collection + "user_collection", + Base.metadata, + Column("user_id", Integer, ForeignKey("users_table.user_id"), primary_key=True), + Column("collection_id", Integer, ForeignKey("collections_table.collection_id"), primary_key=True), +) + + +collection_item = Table( # collection -> item + "collection_item", + Base.metadata, + Column("collection_id", ForeignKey("collections_table.collection_id"), primary_key=True), + Column("item_id", ForeignKey("items_table.item_id"), primary_key=True) +) + ### SECRET KEY ### diff --git a/items/models.py b/items/models.py index 40aec27..b88a6a9 100644 --- a/items/models.py +++ b/items/models.py @@ -4,11 +4,12 @@ from sqlalchemy import DateTime from pydantic import BaseModel from fastapi import Depends from sqlalchemy.orm import Session, relationship, mapped_column, Mapped -from sqlalchemy import ForeignKey, Column, Integer, String, Float +from sqlalchemy import String, Float, Integer, ForeignKey from sqlalchemy.dialects.postgresql import ARRAY -from ..config import Base, get_session_db +from ..config import Base, get_session_db, collection_item from typing import TYPE_CHECKING -from ..auth.models import Role, Status, UserBase, DBUser +from ..auth.models import Role, Status, UserBase +from ..collectionObj.models import CollectionsDB class UserProfileBase(UserBase): @@ -56,61 +57,23 @@ class Item(BaseItem): # Tüm modeller AUTH'da veri tabanına işlendi yukardaki #modeller veri tabanında mevcuttur. Değiştirmek için AUTH'daki # DBUser modelini değiştirip tekrar veri tabanına işleyebilirsin -''' -''' + class Items(Base): __tablename__ = "items_table" item_id : Mapped[int] = mapped_column(primary_key=True, index=True, autoincrement=True) - user_id : Mapped[int] = mapped_column(ForeignKey('users_table.user_id'), nullable=False, index=True) + #collection_id : Mapped[list[int]] = mapped_column(Integer, ForeignKey("collections_table.collection_id"), nullable=True) # collection_id ile ilişki item_created_date : Mapped[datetime] = mapped_column(DateTime, default=datetime.now()) - item_location = Column(String, default="No location") - item_type = Column(String, default="No type") - item_content = Column(String, default="No content") - item_score = Column(Float, default=0.0) + item_location: Mapped[str] = mapped_column(String, default="No location") + item_type: Mapped[str] = mapped_column(String, default="No type") + item_content: Mapped[str] = mapped_column(String, default="No content") + item_score: Mapped[float] = mapped_column(Float, default=0.0) - # ilişkiler - - user : Mapped['DBUser'] = relationship("DBUser", back_populates="items", lazy='select') - #collection = relationship("Collections", back_populates="items") - - -''' -''' -def is_user_exsist_get(username : str, session : Annotated[Session, Depends(get_session_db)]) -> bool | UserProfilePrivate: - #DBUser veritabanındaki nesnedir her niteliğe sahiptir - user = session.query(DBUser).filter(DBUser.username == username).first() - return user - - -def all_users(session: Annotated[Session, Depends(get_session_db)]) -> list[UserProfilePrivate]: - users = session.query(DBUser).all() - - return [UserProfilePrivate( - username=user.username, - bio=user.bio, - created_date=user.created_date, - items = [Item.model_validate(item) for item in user.items], - collections=user.collections, - role=user.role, - status=user.status - ) for user in users] - - -def add_Item_user( - user: Annotated[UserProfileID, Depends(get_session_db)], - session: Annotated[Session, Depends(get_session_db)], - item: ItemCreate) -> bool: - # DBUser veritabanındaki nesnedir her niteliğe sahiptir - - item = Items( - user_id=user.user_id, - item_location=item.item_location, - item_type=item.item_type, - item_content=item.item_content, - item_created_date=item.item_created_date - ) - - session.add(item) - session.commit() - return True + # ilişkiler + collections : Mapped['CollectionsDB']= relationship( + "CollectionsDB", + secondary=collection_item, + back_populates="items", + lazy='select' + ) #back_populates karşı tarafın ismi + \ No newline at end of file diff --git a/items/router.py b/items/router.py index d570b30..8704d2b 100644 --- a/items/router.py +++ b/items/router.py @@ -1,4 +1,4 @@ -from .models import ItemCreate, UserProfileBase, UserProfileID, UserProfilePrivate, UserProfilePublic, add_Item_user, all_users, is_user_exsist_get +from .models import ItemCreate, UserProfileBase, UserProfileID, UserProfilePrivate, UserProfilePublic from fastapi import APIRouter, Depends from sqlalchemy.orm import Session from ..config import get_session_db @@ -12,44 +12,7 @@ router = APIRouter( dependencies=[], ) -@router.get('/all_profiles') -async def get_user_profile(session: Annotated[Session, Depends(get_session_db)]) -> list[UserProfilePrivate]: - - return all_users(session=session) - - -@router.get('/profile/{username}') -async def get_user_profile_by_username( - username: str, - session: Annotated[Session, Depends(get_session_db)], -) -> UserProfilePublic | dict: - - user : UserProfilePublic = is_user_exsist_get(username, session) - if user is None: - return {"error": "User not found"} - - return user - -@router.get('/profile/me') -async def get_user_profile_me( - current_user: Annotated[UserProfilePrivate, Depends(get_current_active_user)], - session : Annotated[Session, Depends(get_session_db)], #dependtek kaynaklı UserPublic doner - ) -> UserProfilePrivate: - - return is_user_exsist_get(current_user.username, session) - - -@router.post('/create') -async def create_user_profile( - user : Annotated[UserProfileID, Depends(get_current_active_user)], - session: Annotated[Session, Depends(get_session_db)], - item : Annotated[ItemCreate , None] = None -) -> dict: - - if add_Item_user(user, session, item) : - return {"message": "User item created successfully"} - - return {"error": "User item creation failed"} +#tüm crud işlemleri yeni veri tabanı modeli ile yapılacak diff --git a/main.py b/main.py index 93010c6..9415e73 100644 --- a/main.py +++ b/main.py @@ -1,7 +1,7 @@ from .config import app from .auth.router import router as auth_router from .items.router import router as items_router -from ._collections.router import router as collections_router +from .collectionObj.router import router as collections_router app.include_router(auth_router) app.include_router(collections_router) From 250d3f1f15624f937fbfce0c2f48c4add2332bac Mon Sep 17 00:00:00 2001 From: bdrtr Date: Wed, 14 May 2025 18:29:46 +0300 Subject: [PATCH 8/8] crud for collections --- collectionObj/models.py | 147 +++++++++++++++++++++++++++++++++++++--- collectionObj/router.py | 54 ++++++++++++++- config.py | 4 +- items/models.py | 3 +- 4 files changed, 195 insertions(+), 13 deletions(-) diff --git a/collectionObj/models.py b/collectionObj/models.py index ef6c257..5ddc1d7 100644 --- a/collectionObj/models.py +++ b/collectionObj/models.py @@ -1,22 +1,43 @@ -from fastapi import HTTPException -from sqlalchemy import Column, Integer, String, Float, Boolean, ForeignKey -from sqlalchemy.dialects.postgresql import ARRAY +from fastapi import HTTPException, Depends +from sqlalchemy import Integer, String, Boolean +from pydantic import BaseModel from sqlalchemy.orm import Session, relationship, mapped_column, Mapped from ..config import Base, get_session_db, user_collection, collection_item +from ..auth.models import DBUser from typing import TYPE_CHECKING if TYPE_CHECKING: - from ..auth.models import DBUser - from ..items.models import Items + from ..items.models import Items, Item + + +###### SCHEMAS ######### +class CollectionBase(BaseModel): + collection_name : str | None = None + collection_description : str | None = None + visibility : bool | None = None + +class CollectionCreate(CollectionBase): + pass + +class CollectionPublic(CollectionBase): + collection_id : int | None = None + + class Config: + from_attributes = True #sqlalchemy ile pydantic arasında geçiş yapabilmek için kullanılır + +class CollectionUpdate(CollectionBase): + pass + + ##### veri tabanı modelleri ##### class CollectionsDB(Base): __tablename__ = "collections_table" - collection_id : Mapped[int] = mapped_column(Integer, primary_key=True) + collection_id : Mapped[int] = mapped_column(Integer, primary_key=True, index=True, autoincrement=True) #user_id : Mapped[int] = mapped_column(Integer, ForeignKey("users_table.user_id"), nullable=False) # user_id ile ilişki #item_id : Mapped[list[int]] = mapped_column(Integer, ForeignKey("items_table.item_id"), nullable=False) # item_id ile ilişki visibility : Mapped[bool] = mapped_column(Boolean, default=True) @@ -24,7 +45,7 @@ class CollectionsDB(Base): collection_description : Mapped[str] = mapped_column(String, default="No description") # ilişkiler - users : Mapped['DBUser'] = relationship( + users : Mapped[list['DBUser']] = relationship( "DBUser", secondary=user_collection, back_populates="collections", @@ -39,4 +60,114 @@ class CollectionsDB(Base): ) - #### collection bir item listesi birde kullanıcı listesi tutacak \ No newline at end of file + #### collection bir item listesi birde kullanıcı listesi tutacak + + + +def create_colletion( + collection: CollectionCreate | None = None, + user_id : int | None = None + +) -> bool: + """ + Collection oluşturma fonksiyonu + """ + if collection is None: + raise HTTPException(status_code=400, detail="Collection is None returned") + + session = next(get_session_db()) # -> get_session_db() fonksiyonu daima generator döndürür next ile çağırmalısın + user = session.query(DBUser).filter(DBUser.user_id == user_id).first() + if user is None: + raise HTTPException(status_code=404, detail="User not found") + + + try: + new_collection = CollectionsDB( + collection_name=collection.collection_name, + collection_description=collection.collection_description, + visibility=collection.visibility + ) + + new_collection.users.append(user) + session.add(new_collection) + session.commit() + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error creating collection: {e}") + + return True + + +def get_collections( + user_id : int | None = None +) -> list[CollectionPublic] | None: + """ + Kullanıcının collectionlarını döndürür + """ + if user_id is None: + raise HTTPException(status_code=400, detail="User id is None") + + session = next(get_session_db()) # -> get_session_db() fonksiyonu daima generator döndürür next ile çağırmalısın + collections = session.query(CollectionsDB).filter(CollectionsDB.users.any(user_id=user_id)).all() + + if collections is None: + raise HTTPException(status_code=404, detail="No collections found") + + return collections + +def update_collection( + collection: CollectionUpdate | None = None, + user_id : int | None = None, + collection_id : int | None = None +) -> bool: + """ + Collection güncelleme fonksiyonu + """ + if collection is None: + raise HTTPException(status_code=400, detail="Collection is None returned") + + session = next(get_session_db()) # -> get_session_db() fonksiyonu daima generator döndürür next ile çağırmalısın + user = session.query(DBUser).filter(DBUser.user_id == user_id).first() + if user is None: + raise HTTPException(status_code=404, detail="User not found") + + collection_to_update = session.query(CollectionsDB).filter(CollectionsDB.collection_id == collection_id).first() + if collection_to_update is None: + raise HTTPException(status_code=404, detail="Collection not found") + + try: + collection_to_update.collection_name = collection.collection_name + collection_to_update.collection_description = collection.collection_description + collection_to_update.visibility = collection.visibility + + session.commit() + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error updating collection: {e}") + + return True + +def delete_collection( + user_id : int | None = None, + collection_id : int | None = None +) -> bool: + """ + Collection silme fonksiyonu + """ + if user_id is None or collection_id is None: + raise HTTPException(status_code=400, detail="User id or collection id is None") + + session = next(get_session_db()) # -> get_session_db() fonksiyonu daima generator döndürür next ile çağırmalısın + user = session.query(DBUser).filter(DBUser.user_id == user_id).first() + if user is None: + raise HTTPException(status_code=404, detail="User not found") + + collection_to_delete = session.query(CollectionsDB).filter(CollectionsDB.collection_id == collection_id).first() + if collection_to_delete is None: + raise HTTPException(status_code=404, detail="Collection not found") + + try: + session.delete(collection_to_delete) + session.commit() + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error deleting collection: {e}") + + return True \ No newline at end of file diff --git a/collectionObj/router.py b/collectionObj/router.py index 72387ea..f258273 100644 --- a/collectionObj/router.py +++ b/collectionObj/router.py @@ -1,8 +1,60 @@ from fastapi import FastAPI, APIRouter +from .models import CollectionPublic, CollectionCreate, CollectionUpdate +from .models import get_collections, create_colletion, update_collection, delete_collection router = APIRouter( prefix="/collections", tags=["collections"], responses={404: {"description": "Not found"}}, dependencies=[], -) \ No newline at end of file +) + + + +@router.get("/{user_id}") +async def get_collections_api(user_id: int) -> list[CollectionPublic]: + """ + Kullanıcının collectionlarını döndürür + """ + + _collections : list[CollectionPublic] = get_collections(user_id=user_id) + + return _collections + + + +@router.post("/{user_id}") +async def create_collection( + user_id: int, + collection: CollectionCreate +) -> bool: + """ + Collection oluşturma fonksiyonu + """ + _result = create_colletion(user_id=user_id, collection=collection) + return _result + + +@router.put("/{user_id}/{collection_id}") +async def update_collection_api( + user_id: int, + collection_id : int, + collection: CollectionUpdate +) -> bool: + """ + Collection güncelleme fonksiyonu + """ + _result = update_collection(user_id=user_id, collection_id=collection_id, collection=collection) + return _result + + +@router.delete("/{user_id}/{collection_id}") +async def delete_collection_api( + user_id: int, + collection_id : int +) -> bool: + """ + Collection silme fonksiyonu + """ + _result = delete_collection(user_id=user_id, collection_id=collection_id) + return _result \ No newline at end of file diff --git a/config.py b/config.py index 2ab13c7..9657ba7 100644 --- a/config.py +++ b/config.py @@ -30,11 +30,11 @@ class Base(DeclarativeBase): #models te içe aktarmayı unutma def init_db(): - Base.metadata.drop_all(engine) # Veritabanını her başlangıcta siler burayada dikkat !!!!!!!! + #Base.metadata.drop_all(engine) # Veritabanını her başlangıcta siler burayada dikkat !!!!!!!! Base.metadata.create_all(bind=engine) # Veritabanını oluşturur # Session dependency (FastAPI için) -def get_session_db(): +def get_session_db() -> 'Generator[Session, None]': db = SessionLocal() try: yield db diff --git a/items/models.py b/items/models.py index b88a6a9..9adbf6d 100644 --- a/items/models.py +++ b/items/models.py @@ -70,10 +70,9 @@ class Items(Base): item_score: Mapped[float] = mapped_column(Float, default=0.0) # ilişkiler - collections : Mapped['CollectionsDB']= relationship( + collections : Mapped[list['CollectionsDB']]= relationship( "CollectionsDB", secondary=collection_item, back_populates="items", lazy='select' ) #back_populates karşı tarafın ismi - \ No newline at end of file