Update backend and server frontend for OAuth JSON response, client-side navigation, and add .gitignore

api/auth.py

@@ -1,17 +1,13 @@
-# api/auth.py
-# SPDX-FileCopyrightText: Hadad <[email protected]>
-# SPDX-License-License: Apache-2.0
-
 from fastapi_users import FastAPIUsers
 from fastapi_users.authentication import CookieTransport, JWTStrategy, AuthenticationBackend
 from httpx_oauth.clients.google import GoogleOAuth2
 from httpx_oauth.clients.github import GitHubOAuth2
-from fastapi_users.manager import BaseUserManager, UUIDIDMixin
+from fastapi_users.manager import BaseUserManager, IntegerIDMixin
 from fastapi import Depends, Request, FastAPI, Response
 from fastapi.responses import JSONResponse
-from fastapi_users_db_mongobeanie import MongoBeanieUserDatabase
-from api.database import User, get_user_db
-from api.models import UserRead, UserCreate, UserUpdate
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from fastapi_users.models import UP
 from typing import Optional
 import os
 import logging
@@ -20,6 +16,9 @@ import httpx
 from datetime import datetime
 import jwt
 
+from api.database import User, OAuthAccount, CustomSQLAlchemyUserDatabase, get_user_db
+from api.models import UserRead, UserCreate, UserUpdate
+
 # إعداد اللوقينج
 logger = logging.getLogger(__name__)
 
@@ -59,10 +58,25 @@ github_oauth_client._access_token_url = "https://github.com/login/oauth/access_t
 github_oauth_client._access_token_params = {"headers": {"Accept": "application/json"}}
 
 # مدير المستخدمين
-class UserManager(UUIDIDMixin, BaseUserManager[User, str]):
+class UserManager(IntegerIDMixin, BaseUserManager[User, int]):
     reset_password_token_secret = SECRET
     verification_token_secret = SECRET
 
+    async def get_by_oauth_account(self, oauth_name: str, account_id: str):
+        logger.info(f"Checking OAuth account: {oauth_name}/{account_id}")
+        statement = select(OAuthAccount).where(
+            OAuthAccount.oauth_name == oauth_name,
+            OAuthAccount.account_id == account_id
+        )
+        result = await self.user_db.session.execute(statement)
+        return result.scalar_one_or_none()
+
+    async def add_oauth_account(self, oauth_account: OAuthAccount):
+        logger.info(f"Adding OAuth account for user {oauth_account.user_id}")
+        self.user_db.session.add(oauth_account)
+        await self.user_db.session.commit()
+        await self.user_db.session.refresh(oauth_account)
+
     async def oauth_callback(
         self,
         oauth_name: str,
@@ -75,22 +89,25 @@ class UserManager(UUIDIDMixin, BaseUserManager[User, str]):
         *,
         associate_by_email: bool = False,
         is_verified_by_default: bool = False,
-    ) -> User:
+    ) -> UP:
         logger.info(f"OAuth callback for {oauth_name} account {account_id}")
 
-        oauth_account_dict = {
-            "oauth_name": oauth_name,
-            "access_token": access_token,
-            "account_id": account_id,
-            "account_email": account_email,
-            "expires_at": expires_at,
-            "refresh_token": refresh_token,
-        }
+        oauth_account = OAuthAccount(
+            oauth_name=oauth_name,
+            access_token=access_token,
+            account_id=account_id,
+            account_email=account_email,
+            expires_at=expires_at,
+            refresh_token=refresh_token,
+        )
 
-        existing_oauth_account = await self.user_db.oauth.get_by_oauth_account(oauth_name, account_id)
+        existing_oauth_account = await self.get_by_oauth_account(oauth_name, account_id)
         if existing_oauth_account:
             logger.info(f"Fetching user for OAuth account with user_id: {existing_oauth_account.user_id}")
-            user = await self.user_db.get(existing_oauth_account.user_id)
+            statement = select(User).where(User.id == existing_oauth_account.user_id)
+            result = await self.user_db.session.execute(statement)
+            user = result.scalar_one_or_none()
+
             if user:
                 logger.info(f"User found: {user.email}, proceeding with on_after_login")
                 await self.on_after_login(user, request)
@@ -103,8 +120,8 @@ class UserManager(UUIDIDMixin, BaseUserManager[User, str]):
             logger.info(f"Associating OAuth account by email: {account_email}")
             user = await self.user_db.get_by_email(account_email)
             if user:
-                oauth_account_dict["user_id"] = user.id
-                await self.user_db.oauth.create(oauth_account_dict)
+                oauth_account.user_id = user.id
+                await self.add_oauth_account(oauth_account)
                 logger.info(f"User associated: {user.email}, proceeding with on_after_login")
                 await self.on_after_login(user, request)
                 return user
@@ -118,17 +135,17 @@ class UserManager(UUIDIDMixin, BaseUserManager[User, str]):
         }
 
         user = await self.user_db.create(user_dict)
-        oauth_account_dict["user_id"] = user.id
-        await self.user_db.oauth.create(oauth_account_dict)
+        oauth_account.user_id = user.id
+        await self.add_oauth_account(oauth_account)
         logger.info(f"New user created: {user.email}, proceeding with on_after_login")
         await self.on_after_login(user, request)
         return user
 
 # استدعاء user manager من get_user_db
-async def get_user_manager(user_db: MongoBeanieUserDatabase = Depends(get_user_db)):
+async def get_user_manager(user_db: CustomSQLAlchemyUserDatabase = Depends(get_user_db)):
     yield UserManager(user_db)
 
-fastapi_users = FastAPIUsers[User, str](
+fastapi_users = FastAPIUsers[User, int](
     get_user_db,
     [auth_backend],
 )

api/database.py

@@ -4,83 +4,143 @@
 
 import os
 import logging
-from typing import AsyncGenerator, Optional, Dict, Any
 from datetime import datetime
+from typing import AsyncGenerator, Optional, Dict, Any
 
-from motor.motor_asyncio import AsyncIOMotorClient
-from beanie import Document, init_beanie
-from fastapi_users_db_mongobeanie import MongoBeanieUserDatabase
-from fastapi_users import models as fu_models
-from fastapi_users_db_mongobeanie.oauth import BeanieBaseOAuthAccount
+from sqlalchemy import Column, String, Integer, ForeignKey, DateTime, Boolean, Text, select
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+from fastapi import Depends
+from fastapi_users.db import SQLAlchemyUserDatabase
+from fastapi_users_db_sqlalchemy import SQLAlchemyBaseUserTable  # استيراد الصحيح
+import aiosqlite
 
 # إعداد اللوج
 logger = logging.getLogger(__name__)
 
-# جلب MONGO_URI من متغيرات البيئة
-MONGO_URI = os.getenv("MONGODB_URI")
-if not MONGO_URI:
-    logger.error("MONGODB_URI is not set in environment variables.")
-    raise ValueError("MONGODB_URI is required for MongoDB.")
-
-# إعداد MongoDB
-client = AsyncIOMotorClient(MONGO_URI)
-mongo_db = client["hager"]
-
-# تعريف نموذج OAuthAccount
-class OAuthAccount(BeanieBaseOAuthAccount, Document):
-    class Settings:
-        name = "oauth_account"
-
-# تعريف نموذج المستخدم
-class User(fu_models.UP, fu_models.OAP, Document):
-    class Settings:
-        name = "user"
-
-    id: fu_models.ID
-    email: str
-    hashed_password: str
-    is_active: bool = True
-    is_superuser: bool = False
-    is_verified: bool = False
-    display_name: Optional[str] = None
-    preferred_model: Optional[str] = None
-    job_title: Optional[str] = None
-    education: Optional[str] = None
-    interests: Optional[str] = None
-    additional_info: Optional[str] = None
-    conversation_style: Optional[str] = None
-    oauth_accounts: list[OAuthAccount] = []
-
-# تعريف نموذج المحادثة
-class Conversation(Document):
-    class Settings:
-        name = "conversation"
-
-    conversation_id: str
-    user_id: fu_models.ID
-    title: str
-    created_at: datetime = datetime.utcnow()
-    updated_at: datetime = datetime.utcnow()
-
-# تعريف نموذج الرسالة
-class Message(Document):
-    class Settings:
-        name = "message"
-
-    conversation_id: str
-    role: str
-    content: str
-    created_at: datetime = datetime.utcnow()
-
-# دالة لتهيئة قاعدة البيانات
+# استخدم القيمة مباشرة إذا لم يكن هناك متغير بيئة
+SQLALCHEMY_DATABASE_URL = os.environ.get(
+    "SQLALCHEMY_DATABASE_URL"
+) or "sqlite+aiosqlite:///./data/mgzon_users.db"
+
+# تأكد أن الدرايفر async
+if "aiosqlite" not in SQLALCHEMY_DATABASE_URL:
+    raise ValueError("Database URL must use 'sqlite+aiosqlite' for async support")
+
+# إنشاء محرك async
+async_engine = create_async_engine(
+    SQLALCHEMY_DATABASE_URL,
+    echo=True,
+    connect_args={"check_same_thread": False}
+)
+
+# إعداد الجلسة async
+AsyncSessionLocal = async_sessionmaker(
+    async_engine,
+    expire_on_commit=False,
+    class_=AsyncSession
+)
+
+# القاعدة الأساسية للنماذج
+Base = declarative_base()
+
+# النماذج (Models)
+class OAuthAccount(Base):
+    __tablename__ = "oauth_account"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("user.id"), nullable=False)
+    oauth_name = Column(String, nullable=False)
+    access_token = Column(String, nullable=False)
+    expires_at = Column(Integer, nullable=True)
+    refresh_token = Column(String, nullable=True)
+    account_id = Column(String, index=True, nullable=False)
+    account_email = Column(String, nullable=False)
+
+    user = relationship("User", back_populates="oauth_accounts", lazy="selectin")
+
+class User(SQLAlchemyBaseUserTable, Base):  # بدون [int] في الإصدار 10.4.2
+    __tablename__ = "user"
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True, nullable=False)
+    hashed_password = Column(String, nullable=False)
+    is_active = Column(Boolean, default=True)
+    is_superuser = Column(Boolean, default=False)
+    is_verified = Column(Boolean, default=False)
+    display_name = Column(String, nullable=True)
+    preferred_model = Column(String, nullable=True)
+    job_title = Column(String, nullable=True)
+    education = Column(String, nullable=True)
+    interests = Column(String, nullable=True)
+    additional_info = Column(Text, nullable=True)
+    conversation_style = Column(String, nullable=True)
+
+    oauth_accounts = relationship("OAuthAccount", back_populates="user", cascade="all, delete-orphan")
+    conversations = relationship("Conversation", back_populates="user", cascade="all, delete-orphan")
+
+class Conversation(Base):
+    __tablename__ = "conversation"
+    id = Column(Integer, primary_key=True, index=True)
+    conversation_id = Column(String, unique=True, index=True, nullable=False)
+    user_id = Column(Integer, ForeignKey("user.id"), nullable=False)
+    title = Column(String, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    user = relationship("User", back_populates="conversations")
+    messages = relationship("Message", back_populates="conversation", cascade="all, delete-orphan")
+
+class Message(Base):
+    __tablename__ = "message"
+    id = Column(Integer, primary_key=True, index=True)
+    conversation_id = Column(Integer, ForeignKey("conversation.id"), nullable=False)
+    role = Column(String, nullable=False)
+    content = Column(Text, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    conversation = relationship("Conversation", back_populates="messages")
+
+# قاعدة بيانات المستخدم المخصصة
+class CustomSQLAlchemyUserDatabase(SQLAlchemyUserDatabase):
+    def __init__(self, session: AsyncSession, user_table, oauth_account_table=None):
+        super().__init__(session, user_table, oauth_account_table)
+
+    def parse_id(self, value: Any) -> int:
+        logger.debug(f"Parsing user id: {value} (type={type(value)})")
+        return int(value) if isinstance(value, str) else value
+
+    async def get_by_email(self, email: str) -> Optional[User]:
+        logger.info(f"Looking for user with email: {email}")
+        stmt = select(self.user_table).where(self.user_table.email == email)
+        result = await self.session.execute(stmt)
+        return result.scalar_one_or_none()
+
+    async def create(self, create_dict: Dict[str, Any]) -> User:
+        logger.info(f"Creating new user: {create_dict.get('email')}")
+        user = self.user_table(**create_dict)
+        self.session.add(user)
+        await self.session.commit()
+        await self.session.refresh(user)
+        return user
+
+# دالة لجلب الجلسة async
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
+
+# دالة لجلب قاعدة بيانات المستخدمين لـ fastapi-users
+async def get_user_db(session: AsyncSession = Depends(get_db)) -> AsyncGenerator[CustomSQLAlchemyUserDatabase, None]:
+    yield CustomSQLAlchemyUserDatabase(session, User, OAuthAccount)
+
+# دالة لإنشاء الجداول
 async def init_db():
     try:
-        await init_beanie(database=mongo_db, document_models=[User, OAuthAccount, Conversation, Message])
-        logger.info("MongoDB initialized successfully")
+        async with async_engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        logger.info("Database tables created successfully")
     except Exception as e:
-        logger.error(f"Error initializing MongoDB: {e}")
+        logger.error(f"Error creating database tables: {e}")
         raise
-
-# دالة لجلب قاعدة بيانات المستخدمين
-async def get_user_db() -> AsyncGenerator[MongoBeanieUserDatabase, None]:
-    yield MongoBeanieUserDatabase(User, OAuthAccount)

main.py

@@ -13,8 +13,8 @@ from starlette.middleware.sessions import SessionMiddleware
 from fastapi.openapi.docs import get_swagger_ui_html
 from fastapi.middleware.cors import CORSMiddleware
 from api.endpoints import router as api_router
-from api.auth import fastapi_users, auth_backend, current_active_user, get_auth_router
-from api.database import User, Conversation, get_user_db, init_db
+from api.auth import fastapi_users, auth_backend, current_active_user, get_auth_router  # أزل أي ذكر لـ google_oauth_router, github_oauth_router
+from api.database import User, Conversation, get_db, init_db
 from api.models import UserRead, UserCreate, UserUpdate
 from motor.motor_asyncio import AsyncIOMotorClient
 from pydantic import BaseModel
@@ -22,6 +22,7 @@ from typing import List
 from contextlib import asynccontextmanager
 import uvicorn
 import markdown2
+from sqlalchemy.ext.asyncio import AsyncSession
 from pathlib import Path
 from hashlib import md5
 from datetime import datetime
@@ -95,7 +96,7 @@ logger.debug(f"Application settings: QUEUE_SIZE={QUEUE_SIZE}, CONCURRENCY_LIMIT=
 # Initialize FastAPI app
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    logger.info("Initializing MongoDB...")
+    logger.info("Initializing database and MongoDB index...")
     await init_db()
     await setup_mongo_index()
     yield
@@ -104,8 +105,8 @@ async def lifespan(app: FastAPI):
 app = FastAPI(
     title="MGZon Chatbot API",
     lifespan=lifespan,
-    docs_url=None,
-    redoc_url=None
+    docs_url=None,  # تعطيل Swagger UI الافتراضي على /docs
+    redoc_url=None   # تعطيل ReDoc الافتراضي لو مش عايزه
 )
 
 # Add SessionMiddleware
@@ -124,23 +125,23 @@ app.add_middleware(
         "https://mgzon-mgzon-app.hf.space",
         "http://localhost:7860",
         "http://localhost:8000",
-        "http://localhost",
-        "https://localhost",
-        "capacitor://localhost",
-        "file://",
+        "http://localhost",  # إضافة لدعم Capacitor على Android/iOS
+        "https://localhost",  # إضافة لدعم HTTPS المحلي
+        "capacitor://localhost",  # دعم Capacitor native apps
+        "file://",  # دعم الملفات المحلية في offline mode
         "https://hager-zon.vercel.app",
         "https://mgzon-mgzon-app.hf.space/auth/google/callback",
         "https://mgzon-mgzon-app.hf.space/auth/github/callback",
     ],
     allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_methods=["*"],  # سمح بكل الـ methods
+    allow_headers=["*"],  # سمح بكل الـ headers
 )
 logger.debug("CORS middleware configured with allowed origins")
 
 # Include routers
 app.include_router(api_router)
-get_auth_router(app)
+get_auth_router(app)  # يضيف الـ custom OAuth endpoints + JWT + register
 logger.debug("API and auth routers included")
 
 # Add logout endpoint
@@ -185,6 +186,13 @@ class NotFoundMiddleware(BaseHTTPMiddleware):
                     {"request": request, "error": "Async context error"},
                     status_code=500
                 )
+            elif "SQLAlchemyUserDatabase' object has no attribute 'parse_id" in str(e):
+                logger.error("JWT error: Missing parse_id in UserDatabase. Check api/database.py configuration.")
+                return templates.TemplateResponse(
+                    "500.html",
+                    {"request": request, "error": "JWT authentication configuration error"},
+                    status_code=500
+                )
             return templates.TemplateResponse(
                 "500.html",
                 {"request": request, "error": str(e)},
@@ -250,15 +258,19 @@ async def chat_conversation(
     request: Request,
     conversation_id: str,
     user: User = Depends(current_active_user),
+    db: AsyncSession = Depends(get_db)
 ):
     if not user:
         logger.debug("Anonymous user attempted to access conversation page, redirecting to /login")
         return RedirectResponse(url="/login", status_code=302)
     
-    conversation = await mongo_db.conversation.find_one({
-        "conversation_id": conversation_id,
-        "user_id": user.id
-    })
+    conversation = await db.execute(
+        select(Conversation).filter(
+            Conversation.conversation_id == conversation_id,
+            Conversation.user_id == user.id
+        )
+    )
+    conversation = conversation.scalar_one_or_none()
     if not conversation:
         logger.warning(f"Conversation {conversation_id} not found for user {user.email}")
         raise HTTPException(status_code=404, detail="Conversation not found")
@@ -269,8 +281,8 @@ async def chat_conversation(
         {
             "request": request,
             "user": user,
-            "conversation_id": conversation["conversation_id"],
-            "conversation_title": conversation["title"] or "Untitled Conversation"
+            "conversation_id": conversation.conversation_id,
+            "conversation_title": conversation.title or "Untitled Conversation"
         }
     )
 

requirements.txt

@@ -1,11 +1,10 @@
 fastapi==0.95.2
 fastapi-users[sqlalchemy,oauth2]==10.4.2
-fastapi-users-db-mongobeanie==2.0.0
-beanie==1.26.0
 pydantic==1.10.13
 email-validator==1.3.1
-motor==3.7.0
-pymongo==4.10.1
+sqlalchemy[asyncio]
+aiosqlite==0.21.0
+sqlalchemy==2.0.43
 python-jose[cryptography]==3.3.0
 passlib[bcrypt]==1.7.4
 bcrypt==4.1.3
@@ -35,8 +34,10 @@ urllib3==2.2.3
 itsdangerous==2.2.0
 protobuf==3.19.6
 aiofiles==24.1.0
+motor==3.7.0
 redis==5.0.0
 markdown2==2.5.0
+pymongo==4.10.1
 parler-tts @ git+https://github.com/huggingface/parler-tts.git@5d0aca9753ab74ded179732f5bd797f7a8c6f8ee
 soupsieve>=2.5
 tqdm>=4.66.0
@@ -48,7 +49,7 @@ librosa>=0.10.0
 matplotlib>=3.10.0
 accelerate>=0.26.0
 diffusers>=0.30.0
-psutil>=6.0.0
+psutil>=5.9.0
 xformers>=0.0.27
 anyio==4.6.0
 pyjwt>=2.4.0