Add users

app/api/v1/endpoints/auth.py

@@ -0,0 +1,25 @@
+# app/api/v1/endpoints/auth.py
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from datetime import timedelta
+from app.models.token import Token
+from app.core.security import create_access_token
+from app.crud.users import authenticate_user
+from app.core.config import settings
+
+router = APIRouter()
+
+@router.post("/token", response_model=Token)
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+    user = await authenticate_user(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=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user["username"]}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}

app/api/v1/endpoints/user.py

@@ -0,0 +1,32 @@
+# app/api/v1/endpoints/user.py
+from fastapi import APIRouter, Depends, HTTPException
+from app.models.users import *
+from app.crud.users import *
+from app.core.security import get_password_hash
+from app.dependencies import get_current_user
+
+router = APIRouter()
+
+@router.post("/")
+async def register_user(user: User):
+
+    db_user = await get_user_by_username(user.username)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Username already exists")
+    
+    db_user = await get_user_by_email(user.email)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Email already exists")
+    
+    user_in_db = UserInDB(**user.dict(), hashed_password=get_password_hash(user.password))
+
+    user_id = await create_user(user_in_db)
+
+    return {"id": user_id}
+
+@router.get("/me/", response_model=User)
+async def read_users_me(current_user: User = Depends(get_current_user)):
+    print("Current user:", current_user)
+
+    
+    return current_user

app/core/config.py

@@ -0,0 +1,19 @@
+
+# app/core/config.py
+import os
+from pydantic import BaseSettings
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    MONGO_DETAILS: str = os.getenv("mongodb_uri")
+    MongoDB_NAME: str = "OCRwebapp"
+    COLLECTION_NAMES: list = ["users", "files", "templates", "extracted data", "external credentials"]
+    SECRET_KEY: str = os.getenv("SECRET_KEY")
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+
+settings = Settings()
+
+print(f"SECRET_KEY: {settings.SECRET_KEY}")  # Add this line to verify the SECRET_KEY

app/core/database.py

@@ -0,0 +1,31 @@
+# app/core/database.py
+from motor.motor_asyncio import AsyncIOMotorClient
+from app.core.config import settings
+
+client = AsyncIOMotorClient(settings.MONGO_DETAILS)
+
+def get_database(db_name:str):
+    return client[db_name]
+
+async def create_collection(db_name:str, collection_name:str):
+    database = get_database(db_name)
+    existing_collections = await database.list_collection_names()
+    if collection_name not in existing_collections:
+        await database.create_collection(collection_name)
+    else:
+        print(f"Collection '{collection_name}' already exists in database '{db_name}'")
+
+
+async def list_collection_names(db_name: str):
+    database = get_database(db_name)
+    collection_names = await database.list_collection_names()
+    return collection_names
+
+async def init_db():
+    print(settings.MongoDB_NAME)
+    for collection_name in settings.COLLECTION_NAMES:
+        await create_collection(settings.MongoDB_NAME, collection_name)
+    
+    collections = await list_collection_names(settings.MongoDB_NAME)
+    print(f"Collections in '{settings.MongoDB_NAME}': {collections}")
+ 

app/core/security.py

@@ -0,0 +1,36 @@
+# app/core/security.py
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from fastapi.security import OAuth2PasswordBearer
+from passlib.context import CryptContext
+from app.core.config import settings
+from fastapi import Depends, HTTPException, status
+
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt
+
+def decode_access_token(token: str):
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        return payload
+    except JWTError:
+        return None
+
+

app/crud/users.py

@@ -0,0 +1,33 @@
+# app/crud/user.py
+from app.core.database import get_database
+from app.models.users import UserInDB, User
+from app.core.security import get_password_hash, verify_password
+from bson import ObjectId
+from app.core.config import settings
+
+
+async def create_user(user: UserInDB):
+    user_dict = user.dict()
+    user_dict["password"] = get_password_hash(user.password)
+    db = get_database(settings.MongoDB_NAME)
+    result = await db["users"].insert_one(user_dict)
+    user_dict["_id"] = str(result.inserted_id)
+    return User(**user_dict)
+
+async def get_user_by_username(username: str):
+    db = get_database(settings.MongoDB_NAME)
+    user = await db["users"].find_one({"username": username})
+    
+    return user
+
+async def get_user_by_email(email: str):
+    db = get_database(settings.MongoDB_NAME)
+    user = await db["users"].find_one({"email": email})
+    return user
+
+async def authenticate_user(username: str, password: str):
+    user = await get_user_by_username(username)
+    print("User:", user)
+    if user and verify_password(password, user["password"]):
+        return user
+    return False

app/db/base.py

@@ -1,5 +1,5 @@
 import asyncio, contextlib, logging, os, sys, time
-from dotenv import load_dotenv
+from dotenv import load_dotenv, dotenv_values
 from typing import AsyncIterator, Any, Dict, List, Optional, Tuple, Type, Union
 # from app.db.models.models import Base
 
@@ -10,7 +10,7 @@ from sqlalchemy.ext.asyncio import (
 )
 
 
-load_dotenv()
+dotenv_values(".env")
 
 from sqlalchemy import text
 from sqlalchemy.orm import declarative_base
@@ -20,21 +20,21 @@ Base = declarative_base()
 # # Define the MySQL connection details
 username = os.getenv("usernameDb")
 password = os.getenv("password")
-host = os.getenv("host")  # e.g., 'localhost' or '127.0.0.1'
-# port = os.getenv("port")  # Default MySQL port
-database_name = os.getenv("database_name")
+host = os.getenv("host")  
+port = os.environ.get("port")  
+mysql_name = os.getenv("MySQLDatabaseName")
 
 
 # username = 'hidh4125_admin'
 # password = 'Alberto471'
 # host = 'hidigi.asia'  # e.g., 'localhost' or '127.0.0.1'
-port = '3306'  # Default MySQL port
+# port = '3306'  # Default MySQL port
 # database_name = 'hidh4125_speechRecognition'
 
-print(username,password,host,port,database_name)
+print('port:',port)
 
 # Create an engine to connect to the MySQL server
-engine = create_async_engine(f'mysql+aiomysql://{username}:{password}@{host}:{port}/{database_name}', echo=True, future=True)
+engine = create_async_engine(f'mysql+aiomysql://{username}:{password}@{host}:{port}/{mysql_name}', echo=True, future=True)
 
 
 async_session = async_sessionmaker(

app/dependencies.py

@@ -0,0 +1,28 @@
+# app/dependencies.py
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+from app.models.token import TokenData
+from app.crud.users import get_user_by_username
+from app.core.config import settings
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+    user = await get_user_by_username(username=token_data.username)
+    if user is None:
+        raise credentials_exception
+    return user

app/main.py

@@ -13,41 +13,38 @@ from bson import ObjectId
 from contextlib import asynccontextmanager
 from pydantic import BaseModel, Field
 from datetime import timedelta, datetime
-from dotenv import load_dotenv
+from dotenv import load_dotenv, dotenv_values
+from app.api.v1.endpoints import user, auth
 from app.db.base import *
 from app.core.auth import *
-from app.router.user import *
+# from app.router.user import *
+from app.core.database import *
 
 # Load environment variables from .env file
-load_dotenv()
+dotenv_values(".env")
 
 
 # Read environment variables
 host = os.getenv("HOST", "0.0.0.0")
 port = os.getenv("PORT", 8080)
-print(host,port)
+
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Connect to MongoDB
-mongodb_uri = os.getenv('mongodb_uri')
-db_name = os.getenv('DB_NAME')
-
-if not mongodb_uri or not db_name:
-    logger.error("Environment variables mongodb_uri or DB_NAME are not set.")
-    raise ValueError("Environment variables mongodb_uri or DB_NAME are not set.")
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    app.mongodb_client = MongoClient(mongodb_uri)
-    app.database = app.mongodb_client[db_name]
+    # app.mongodb_client = MongoClient(mongodb_uri)
+    # app.database = app.mongodb_client[db_name]
+   
     logger.info("Connected to the MongoDB database!")
     
     try:
-        collections = app.database.list_collection_names()
-        print(f"Collections in {db_name}: {collections}")
+        await init_db()
+        # collections = app.database.list_collection_names()
+        # print(f"Collections in {db_name}: {collections}")
         yield
     except Exception as e:
         logger.error(e)
@@ -61,7 +58,8 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-app.include_router(router, prefix='/api/v1/user', tags=["User"])
+app.include_router(user.router, prefix='/api/v1/user', tags=["User"])
+app.include_router(auth.router, tags=["Auth"])
 
 
 class Destination(BaseModel):

app/models/token.py

@@ -0,0 +1,10 @@
+# app/schemas/token.py
+from pydantic import BaseModel
+from typing import Optional
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    username: Optional[str] = None

app/models/users.py

@@ -0,0 +1,14 @@
+# app/models/user.py
+from pydantic import BaseModel, EmailStr, Field
+from typing import Optional
+from datetime import timedelta, datetime
+
+class User(BaseModel):
+    username: str
+    email: EmailStr
+    password: str
+
+class UserInDB(User):
+    is_validated: bool = Field(default=False)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: Optional[str] = None