Merge pull request #15 from vcjuliocesar/refactor/feature

vcjuliocesar · web-flow · commit 5d190ffdd412 · 2023-09-02T19:02:39.000-06:00
refactor
diff --git a/.env.example b/.env.example
@@ -0,0 +1,15 @@
+#Enviroment
+#ENVIROMENT=production
+ENVIROMENT=development
+
+#Auth
+TOKEN_EXPIRE_MINUTES=3600
+MY_SECRET_KEY=bb635b7c649162d4623307e6633dfb595437bd7cefe86cc63349156cc52b212c
+
+#Database
+DB_NAME=root
+DB_USER=root
+DB_PASS=6UF4Kie7tzLSeThX78tqBUuptI1th8T6 
+DB_HOST=localhost
+DB_PORT=5432
+
diff --git a/README.md b/README.md
@@ -12,7 +12,8 @@ Follow these steps to set up and run the project on your local machine:
 ```sh 
 git clone git@github.com:vcjuliocesar/pynotes-api.git
 ```
-rename env.example by .env
+**Create enviroment file**
+rename .env.example by .env
 
 **Create a Virtual Environment:**
 ```sh
diff --git a/config/config.py b/config/config.py
@@ -4,13 +4,17 @@
 settings = Settings()
 
 class ProductionConfig:
+    
     DATABASE_URI = f"postgresql://{settings.DB_USER}:{settings.DB_PASS}@{settings.DB_HOST}/{settings.DB_NAME}"
+    
     DEBUG = False
     
 class DevelopmentConfig:
+    
     sqlite_file_name = "../database.sqlite"
 
     base_dir = os.path.dirname(os.path.realpath(__file__))
     
     DATABASE_URI = f"sqlite:///{os.path.join(base_dir,sqlite_file_name)}"
+    
     DEBUG = True
diff --git a/config/database.py b/config/database.py
@@ -1,4 +1,3 @@
-import os
 from sqlalchemy import create_engine
 from sqlalchemy.orm.session import sessionmaker
 from sqlalchemy.ext.declarative import declarative_base
@@ -8,11 +7,13 @@
 settings = Settings()
 
 if settings.ENVIROMENT == "production":
+    
     conf = ProductionConfig
     
     database_url = conf.DATABASE_URI
 
 else:
+    
     conf = DevelopmentConfig
     
     database_url = conf.DATABASE_URI
diff --git a/env.example b/env.example
diff --git a/main.py b/main.py
@@ -1,7 +1,4 @@
-from fastapi import FastAPI,HTTPException,status
-from fastapi.security import HTTPBearer
-from utils.jwt_manager import validate_token
-from starlette.requests import Request
+from fastapi import FastAPI
 from config.database import engine,Base
 from middlewares.error_handler import ErrorHandler
 from config.config import ProductionConfig,DevelopmentConfig
diff --git a/middlewares/error_handler.py b/middlewares/error_handler.py
@@ -6,11 +6,15 @@
 from starlette.responses import Response
 
 class ErrorHandler(BaseHTTPMiddleware):
+    
     def __init__(self, app: FastAPI) -> None:
         super().__init__(app)
         
     async def dispatch(self, request: Request, call_next) -> Response | JSONResponse:
         try:
+        
             return await call_next(request)
+        
         except Exception as error:
+        
             return JSONResponse(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,content={"error":str(error)})
diff --git a/middlewares/jwt_bearer.py b/middlewares/jwt_bearer.py
@@ -4,24 +4,34 @@
 from starlette.requests import Request
 from services.user import UserService
 from config.database import Session
-from datetime import datetime,timedelta
+from datetime import datetime
 
 class JWTBearer(HTTPBearer):
+    
     async def __call__(self, request: Request):
+        
         credentials_exception = HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,detail="Ivalid Credentials")
+        
         db = Session()
+        
         auth = await super().__call__(request)
+        
         data = validate_token(auth.credentials)
+        
         expire = datetime.fromtimestamp(data['exp'])
+        
         user = UserService(db).get_user_by_email(email=data["email"])
         
         if not user:
+        
             raise credentials_exception
         
         if expire is None:
+        
             raise credentials_exception
         
         if datetime.utcnow() > expire:
+        
             raise credentials_exception
         
         return user
diff --git a/models/note.py b/models/note.py
@@ -7,8 +7,11 @@ class Note(Base):
     __tablename__ = "notes"
     
     id = Column(Integer,primary_key=True)
+    
     title = Column(String)
+    
     content = Column(String)
+    
     owner_id = Column(Integer,ForeignKey("users.id"))
     
     owner = relationship("User",back_populates="notes") 
diff --git a/models/user.py b/models/user.py
@@ -7,8 +7,11 @@ class User(Base):
     __tablename__ = "users"
     
     id = Column(Integer,primary_key=True)
+    
     email = Column(String,unique=True)
+    
     password = Column(String)
+    
     is_active = Column(Boolean,default=True)
     
     notes = relationship("Note",back_populates="owner")
diff --git a/routers/note.py b/routers/note.py
@@ -11,19 +11,26 @@
 
 @note_router.get('/',tags=['Notes'],response_model=List[Note],status_code=status.HTTP_200_OK,dependencies=[Depends(JWTBearer())])
 def get_notes(token:str = Depends(JWTBearer())) -> List[Note]:
+    
     db = Session()
+    
     result = NoteService(db).get_notes(token.id)
+    
     if not result:
+    
         return JSONResponse(status_code=status.HTTP_404_NOT_FOUND,content={"message":"Note not found"})
     
     return JSONResponse(status_code=status.HTTP_200_OK,content=jsonable_encoder(result))
 
 @note_router.get('/notes/{id}',tags=['Notes'],response_model=Note,status_code=status.HTTP_200_OK,dependencies=[Depends(JWTBearer())])
 def get_note(id:int = Path(le=2000),token:str = Depends(JWTBearer())) ->Note :
+    
     db = Session()
+    
     result = NoteService(db).get_note(id,token.id)
     
     if not result:
+    
         return JSONResponse(status_code=status.HTTP_404_NOT_FOUND,content={"message":"Note not found"})
     
     return JSONResponse(status_code=status.HTTP_200_OK,content=jsonable_encoder(result))
@@ -32,26 +39,40 @@ def get_note(id:int = Path(le=2000),token:str = Depends(JWTBearer())) ->Note :
 
 @note_router.post('/notes',tags=['Notes'],response_model=dict,status_code=status.HTTP_200_OK,dependencies=[Depends(JWTBearer())])
 def create_note(note:NoteCreate,token:str = Depends(JWTBearer())) -> dict:
+    
     db = Session()
+    
     NoteService(db).create_note(note,token.id)
+    
     return JSONResponse(status_code=status.HTTP_201_CREATED,content={"message":"Note created successfully"})
 
 @note_router.put('/notes',tags=['Notes'],response_model=dict,status_code=status.HTTP_200_OK,dependencies=[Depends(JWTBearer())])
 def update_note(id:int,note:NoteBase,token:str = Depends(JWTBearer()))->dict:
+    
     db = Session()
+    
     result = NoteService(db).get_note(id,token.id)
     
     if not result:
+    
         return JSONResponse(status_code=status.HTTP_400_BAD_REQUEST,content={"message":"Oops, something went wrong! Try again later."})
+    
     NoteService(db).update_note(id,note,token.id)
+    
     return JSONResponse(status_code=status.HTTP_200_OK,content={"message":"Note updated successfully"})
     
 
 @note_router.delete('/notes/{id}',tags=['Notes'],response_model=dict,status_code=status.HTTP_200_OK,dependencies=[Depends(JWTBearer())])
 def delete_note(id:int,token:str = Depends(JWTBearer())) -> dict:
+    
     db = Session()
+    
     result = NoteService(db).get_note(id,token.id)
+    
     if not result:
+    
         return JSONResponse(status_code=status.HTTP_400_BAD_REQUEST,content={"message":"Oops, something went wrong! Try again later."})
+    
     NoteService(db).delete_note(id,token.id)
+    
     return JSONResponse(status_code=status.HTTP_200_OK,content={"message":"Note deleted successfully"})
diff --git a/routers/user.py b/routers/user.py
@@ -10,20 +10,30 @@
 
 @user_router.post('/users',tags=['Auth'],response_model=User,status_code=status.HTTP_200_OK)
 def create_user(user:UserCreate):
+    
     db = Session()
+    
     result = UserService(db).get_user_by_email(email=user.email)
     
-    if not result:
-        UserService(db).create_user(user)
-        return JSONResponse(status_code=status.HTTP_200_OK,content={"message":"User created"})
-    return JSONResponse(status_code=status.HTTP_400_BAD_REQUEST,content={"message":"User already exists"})
+    if result:
+    
+        return JSONResponse(status_code=status.HTTP_400_BAD_REQUEST,content={"message":"User already exists"})
+    
+    UserService(db).create_user(user)
+    
+    return JSONResponse(status_code=status.HTTP_200_OK,content={"message":"User created"})
+    
 
 @user_router.post('/login',tags=['Auth'],status_code=status.HTTP_200_OK)
 def login(user:UserCreate):
+    
     db = Session()
     result = UserService(db).get_user_by_email(email=user.email)
     
-    if result and Auth().verify_password(user.password,result.password):
-        token:str = create_token(user.dict())
-        return JSONResponse(status_code=status.HTTP_200_OK,content=token)
-    return JSONResponse(status_code=status.HTTP_401_UNAUTHORIZED,content={"message":"Unauthorized"})
+    if not (result and Auth().verify_password(user.password,result.password)):
+        
+        return JSONResponse(status_code=status.HTTP_401_UNAUTHORIZED,content={"message":"Unauthorized"})
+    
+    token:str = create_token(user.dict())
+    
+    return JSONResponse(status_code=status.HTTP_200_OK,content=token)
diff --git a/schemas/note.py b/schemas/note.py
@@ -2,8 +2,9 @@
 from typing import Optional
 
 class NoteBase(BaseModel):
-    #id:Optional[int] = Field(default=None)
+    
     title:str = Field(min_length=5,max_length=15)
+    
     content:str = Field(min_length=5,max_length=200)
     
     class Config:
@@ -13,11 +14,14 @@ class Config:
                 'content':'my content'
             }
         }
+        
 class NoteCreate(NoteBase):
     pass
 
 class Note(NoteBase):
+    
     id:Optional[int] = Field(default=None)
+    
     owner_id:int
     
     class Config:
diff --git a/schemas/user.py b/schemas/user.py
@@ -3,21 +3,29 @@
 
 
 class UserBase(BaseModel):
+    
     email:str
+    
     class Config:
+    
         json_schema_extra = {
             "example":{
                 'email':'jhon.doe@fake.com',
                 'password':'admin123@'
             }
         }
 
+
 class UserCreate(UserBase):
+
     password:str = Field(min_length=8,max_length=16)
         
     
+
 class User(UserBase):
+
     id:Optional[int] = Field(default=None)
+
     is_active:bool
     
     class Config:
diff --git a/services/auth.py b/services/auth.py
@@ -1,11 +1,15 @@
 from passlib.context import CryptContext
 
 class Auth():
+    
     def __init__(self):
+    
         self.pwd_context = CryptContext(schemes=['bcrypt'],deprecated="auto")
         
     def verify_password(self,password:str,hash:str):
+    
         return self.pwd_context.verify(password,hash)
     
     def get_password(self,password:str):
+    
         return self.pwd_context.hash(password)
diff --git a/services/note.py b/services/note.py
diff --git a/services/user.py b/services/user.py
