feat:Added gmail api

src/core/config.py

@@ -33,6 +33,14 @@ class Settings(BaseSettings):
     FERNET_KEY: str
     VERIFICATION_BASE_URL: str
 
+    GOOGLE_CLIENT_ID: str
+    GOOGLE_CLIENT_SECRET: str
+    GOOGLE_REDIRECT_URI: str
+
+    AUTH_BASE: str = "https://accounts.google.com/o/oauth2/v2/auth"
+    TOKEN_URL: str = "https://oauth2.googleapis.com/token"
+    GMAIL_SEND_SCOPE: str = "https://www.googleapis.com/auth/gmail.send"
+
     @computed_field
     @property
     def DATABASE_URL(self) -> PostgresDsn:
@@ -45,8 +53,9 @@ class Settings(BaseSettings):
         """Async DB URL"""
         return f"postgresql+asyncpg://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}/{self.POSTGRES_DB}"
 
-    model_config = SettingsConfigDict(env_file=".env", case_sensitive=False)
-
+    model_config = SettingsConfigDict(
+        env_file=".env", case_sensitive=False, env_file_encoding="utf-8"
+    )
 
 
 settings = Settings()

src/main.py

@@ -1,11 +1,10 @@
-from src.assets.router import router as assets
 from src.profile.router import router as profile
 from fastapi import FastAPI
 
 from src.core.database import init_db
 from src.home.router import router as home_router
 from src.auth.router import router as auth_router
-from src.leave.router import router as leave
+
 
 app = FastAPI(title="Yuvabe App API")
 

src/profile/router.py

@@ -1,3 +1,10 @@
+from src.profile.service import send_email_service
+from src.profile.schemas import SendMailRequest
+from src.profile.utils import build_auth_url
+from src.profile.utils import exchange_code_for_tokens
+from src.profile.service import USER_TOKEN_STORE
+from src.profile.utils import send_email
+from src.profile.service import list_user_assets
 from fastapi.routing import APIRouter
 from src.core.database import get_async_session
 from src.auth.utils import get_current_user
@@ -6,23 +13,66 @@ from sqlalchemy.ext.asyncio.session import AsyncSession
 from fastapi.params import Depends
 from .schemas import UpdateProfileRequest
 from src.profile.service import update_user_profile
-from fastapi import APIRouter, Depends
-from sqlmodel.ext.asyncio.session import AsyncSession
-from src.core.database import get_async_session
-from src.auth.utils import get_current_user
-from src.assets.schemas import BaseResponse
-from src.assets.service import list_user_assets
-from src.leave.utils import send_email
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
 from sqlmodel import select
-from sqlmodel.ext.asyncio.session import AsyncSession
-from src.auth.utils import get_current_user
 from src.core.models import Users, Teams, Roles, UserTeamsRole
-from fastapi import BackgroundTasks
 
 
 router = APIRouter(prefix="/profile", tags=["Profile"])
 
+# src/routers/gmail_oauth_router.py
+from fastapi import APIRouter, Query, HTTPException
+from fastapi.responses import RedirectResponse, JSONResponse
+import httpx
+
+
+router = APIRouter(prefix="/gmail", tags=["Gmail OAuth"])
+
+
+@router.get("/login")
+def google_login(state: str | None = Query(None)):
+    return RedirectResponse(build_auth_url(state))
+
+
+@router.get("/callback")
+async def google_callback(code: str | None = None, state: str | None = None):
+    if not code:
+        raise HTTPException(400, "Missing code")
+
+    token_data = await exchange_code_for_tokens(code)
+    access_token = token_data["access_token"]
+    refresh_token = token_data.get("refresh_token")
+
+    # Get user info
+    async with httpx.AsyncClient() as client:
+        r = await client.get(
+            "https://www.googleapis.com/oauth2/v3/userinfo",
+            headers={"Authorization": f"Bearer {access_token}"}
+        )
+    userinfo = r.json()
+
+    google_user_id = userinfo["sub"]
+    user_email = userinfo["email"]
+
+    USER_TOKEN_STORE[google_user_id] = {
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "email": user_email
+    }
+
+    return JSONResponse({
+        "status": "ok",
+        "user_id": google_user_id,
+        "email": user_email,
+        "state": state,
+    })
+
+
+@router.post("/send-mail")
+async def send_mail(req: SendMailRequest):
+    return await send_email_service(req)
+
+
 
 @router.get("/", response_model=BaseResponse)
 async def get_assets(
@@ -56,7 +106,6 @@ async def update_profile(
     return {"code": 200, "data": result}
 
 
-
 @router.get("/contacts", response_model=BaseResponse)
 async def get_leave_contacts(
     current_user=Depends(get_current_user),
@@ -135,4 +184,3 @@ async def send_leave_email(
     background.add_task(send_email, to_email, subject, body, cc, from_email)
 
     return BaseResponse(code=200, message="Leave request sent", data=None)
-

src/profile/schemas.py

@@ -3,22 +3,26 @@ from typing import Optional
 import uuid
 from enum import Enum
 
+
 class AssetStatus(str, Enum):
     ACTIVE = "Active"
     UNAVAILABLE = "Unavailable"
     ON_REQUEST = "On Request"
     IN_SERVICE = "In Service"
 
+
 class AssetCreateRequest(BaseModel):
     name: str
     type: str
     status: Optional[AssetStatus] = AssetStatus.UNAVAILABLE
 
+
 class AssetUpdateRequest(BaseModel):
     name: Optional[str] = None
     type: Optional[str] = None
     status: Optional[AssetStatus] = None
 
+
 class AssetResponse(BaseModel):
     id: uuid.UUID
     user_id: uuid.UUID
@@ -26,6 +30,7 @@ class AssetResponse(BaseModel):
     type: str
     status: AssetStatus
 
+
 class BaseResponse(BaseModel):
     code: int
     data: dict
@@ -39,3 +44,11 @@ class UpdateProfileRequest(BaseModel):
 
     current_password: Optional[str] = None
     new_password: Optional[str] = None
+
+
+class SendMailRequest(BaseModel):
+    user_id: str
+    to: EmailStr
+    subject: str
+    body: str
+    from_name: Optional[str] = None

src/profile/service.py

@@ -1,3 +1,6 @@
+from src.profile.utils import build_raw_message
+from src.profile.utils import refresh_access_token
+from src.profile.schemas import SendMailRequest
 from src.core.models import Assets
 from ast import List
 from datetime import datetime
@@ -10,10 +13,55 @@ from typing import List
 from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
 from src.core.models import Assets
+import httpx
+from src.core.config import settings
+
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 
+# In production, replace with DB storage
+USER_TOKEN_STORE = {}  # {google_user_id: {tokens}}
+
+
+async def send_email_service(req: SendMailRequest):
+    record = USER_TOKEN_STORE.get(req.user_id)
+    if not record:
+        raise HTTPException(404, "User not logged in with Google OAuth")
+
+    access_token = record["access_token"]
+    refresh_token = record.get("refresh_token")
+
+    if not access_token and refresh_token:
+        new_tokens = await refresh_access_token(refresh_token)
+        access_token = new_tokens["access_token"]
+        record["access_token"] = access_token
+
+    if not access_token:
+        raise HTTPException(400, "Re-auth required")
+
+    raw = build_raw_message(
+        to_email=req.to,
+        subject=req.subject,
+        body=req.body,
+        from_name=req.from_name,
+        from_email=record["email"],
+    )
+
+    url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
+    payload = {"raw": raw}
+
+    async with httpx.AsyncClient() as client:
+        r = await client.post(
+            url, json=payload, headers={"Authorization": f"Bearer {access_token}"}
+        )
+
+    if r.status_code >= 400:
+        raise HTTPException(500, f"Gmail error: {r.text}")
+
+    return r.json()
+
+
 async def update_user_profile(session, user_id: str, data):
     user = await session.get(Users, uuid.UUID(user_id))
 
@@ -71,8 +119,7 @@ async def update_user_profile(session, user_id: str, data):
         },
     }
 
+
 async def list_user_assets(session: AsyncSession, user_id: str) -> List[Assets]:
-    q = await session.exec(
-        select(Assets).where(Assets.user_id == uuid.UUID(user_id))
-    )
-    return q.all()
+    q = await session.exec(select(Assets).where(Assets.user_id == uuid.UUID(user_id)))
+    return q.all()

src/profile/utils.py

@@ -3,6 +3,12 @@ import smtplib
 from email.message import EmailMessage
 from src.core.config import settings
 from typing import List
+import base64
+import httpx
+from typing import Dict, Optional
+from src.core.config import settings
+from urllib.parse import urlencode
+
 
 
 SMTP_HOST = settings.EMAIL_SERVER
@@ -11,6 +17,69 @@ SMTP_USER = settings.EMAIL_USERNAME
 SMTP_PASS = settings.EMAIL_PASSWORD
 FROM_DEFAULT = settings.EMAIL_USERNAME
 
+# src/utils/gmail_utils.py
+
+
+def build_auth_url(state=None):
+    params = {
+        "client_id": settings.GOOGLE_CLIENT_ID,
+        "redirect_uri": settings.GOOGLE_REDIRECT_URI,
+        "response_type": "code",
+        "scope": settings.GMAIL_SEND_SCOPE + " openid email profile",
+        "access_type": "offline",
+        "prompt": "consent",
+    }
+
+    if state:
+        params["state"] = state
+
+    query = urlencode(params)
+    return f"{settings.AUTH_BASE}?{query}"
+
+
+async def exchange_code_for_tokens(code: str) -> Dict:
+    data = {
+        "code": code,
+        "client_id": settings.GOOGLE_CLIENT_ID,
+        "client_secret": settings.GOOGLE_CLIENT_SECRET,
+        "redirect_uri": settings.GOOGLE_REDIRECT_URI,
+        "grant_type": "authorization_code",
+    }
+
+    async with httpx.AsyncClient() as client:
+        r = await client.post(settings.TOKEN_URL, data=data)
+        r.raise_for_status()
+        return r.json()
+
+
+async def refresh_access_token(refresh_token: str) -> Dict:
+    data = {
+        "client_id": settings.GOOGLE_CLIENT_ID,
+        "client_secret": settings.GOOGLE_CLIENT_SECRET,
+        "refresh_token": refresh_token,
+        "grant_type": "refresh_token",
+    }
+
+    async with httpx.AsyncClient() as client:
+        r = await client.post(settings.TOKEN_URL, data=data)
+        r.raise_for_status()
+        return r.json()
+
+
+def build_raw_message(
+    to_email: str, subject: str, body: str, from_name: Optional[str], from_email: str
+) -> str:
+
+    msg = EmailMessage()
+    sender = f"{from_name} <{from_email}>" if from_name else from_email
+    msg["From"] = sender
+    msg["To"] = to_email
+    msg["Subject"] = subject
+    msg.set_content(body)
+
+    raw_bytes = msg.as_bytes()
+    return base64.urlsafe_b64encode(raw_bytes).decode()
+
 
 def send_email(
     to_email: str, subject: str, body: str, cc: list[str] = None, from_email: str = None