Merge pull request #31 from Backendly/payment

Payment

Author: ezeisraeljohn

api/main.py

@@ -12,7 +12,6 @@
 )
 import os
 import uvicorn
-from jobs.payment_jobs import receive_orders
 import sentry_sdk
 from dotenv import load_dotenv
 
@@ -33,7 +32,7 @@
 )
 
 
-receive_orders.delay()
+# recieve_orders.delay()
 
 
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True)

api/v1/crud/account_crud.py

@@ -1,17 +1,20 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing import Any
 from services.stripe_config import stripe
-from fastapi import Request, HTTPException, Depends
+from fastapi import Request, HTTPException
 from datetime import datetime
 from typing import Dict
 from db.session import redis_instance
 import os
+from fastapi.background import BackgroundTasks
+from backgrounds import save_connected_account
 
 
 async def create_connected_account(
     data: Request,
     session: AsyncSession,
     validated_developer: Dict[str, Any],
+    background_tasks: BackgroundTasks,
 ):
     """Creates a connected account"""
     data = await data.json()
@@ -45,6 +48,8 @@ async def create_connected_account(
             status_code=500,
             detail=f"An error occurred while creating the connected account.{e}",
         )
+    data["account_id"] = account["id"]
+    background_tasks.add_task(save_connected_account, data, session, developer_id)
 
     full_onboard_url = stripe.AccountLink.create(
         account=account["id"],

api/v1/crud/payment_method_crud.py

@@ -1,50 +1,45 @@
 from models.payment_method_model import PaymentMethod
 from services.stripe_config import stripe
 from sqlalchemy.ext.asyncio import AsyncSession
-from fastapi import HTTPException
+from fastapi import HTTPException, Request
 from sqlalchemy.future import select
-from ..schema.payment_method_schema import (
-    PaymentMethodCreate,
-    PaymentMethodInDB,
-    PaymentMethodType,
-)
+from typing import Dict
 
 
 async def create_payment_method(
-    payment_method: PaymentMethodCreate, session: AsyncSession
+    data: Request,
+    session: AsyncSession,
+    validated_developer: Dict | str,
+    validated_user: Dict | str,
+    validated_app: Dict | str,
 ):
     """Creates a new payment method"""
-    payment_method_dict = payment_method.model_dump()
-    payment_method_type = payment_method_dict["type"]
-    payment_method_details = payment_method_dict["details"]
-
-    if payment_method_type == PaymentMethodType.card:
-        try:
-            payment_method_stripe = await stripe.PaymentMethod.create(
-                type="card",
-                card={
-                    "number": payment_method_details["card_number"],
-                    "exp_month": payment_method_details["exp_month"],
-                    "exp_year": payment_method_details["exp_year"],
-                    "cvc": payment_method_details["card_cvc"],
-                },
-            )
-        except Exception as e:
-            raise HTTPException(
-                status_code=500,
-                detail=f"An error occurred while creating the payment method.{e}",
-            )
-        new_payment_method = PaymentMethod(
-            id=payment_method_stripe["id"],
-            type=payment_method_type,
-            details={
-                "card_last_four": payment_method_stripe["last4"],
-                "card_type": payment_method_stripe["brand"],
-                "exp_month": payment_method_stripe["exp_month"],
-                "exp_year": payment_method_stripe["exp_year"],
-            },
-        )
-
+    developer_id = (
+        validated_developer.get("developer_id")
+        if type(validated_developer) == dict
+        else validated_developer
+    )
+    user_id = (
+        validated_user.get("user_id")
+        if type(validated_user) == dict
+        else validated_user
+    )
+    app_id = (
+        validated_app.get("app_id") if type(validated_app) == dict else validated_app
+    )
+    payment_method_dict = await data.json()
+    payment_method_type = payment_method_dict.get("type")
+    preffered = payment_method_dict.get("preferred", False)
+    payment_method_id = payment_method_dict.get("payment_method_id", None)
+
+    new_payment_method = PaymentMethod(
+        payment_method_id=payment_method_id,
+        user_id=user_id,
+        app_id=app_id,
+        developer_id=developer_id,
+        type=payment_method_type,
+        preferred=preffered,
+    )
     try:
         session.add(new_payment_method)
         await session.commit()
@@ -57,56 +52,3 @@ async def create_payment_method(
         )
 
     return new_payment_method
-
-
-async def get_payment_methods(session: AsyncSession, limit: int, offset: int):
-    """Returns all payment methods"""
-    result = await session.execute(select(PaymentMethod).limit(limit).offset(offset))
-    results = result.scalars().all()
-    new_results = []
-    for result in results:
-        result = PaymentMethodInDB.model_validate(result)
-        result = result.model_dump()
-        del result["details"]["card_cvc"]
-        result["details"]["card_last_four"] = result["details"]["card_number"][-4:]
-        del result["details"]["card_number"]
-        new_results.append(result)
-
-    return new_results
-
-
-async def get_payment_method(id: str, session: AsyncSession):
-    """Returns a payment method by id"""
-    result = await session.execute(
-        select(PaymentMethod).filter(PaymentMethod.id == id),
-    )
-    payment_method = result.scalars().first()
-    if not payment_method:
-        raise HTTPException(
-            status_code=404,
-            detail="Payment method not found",
-        )
-    result = payment_method
-    result = PaymentMethodInDB.model_validate(result)
-    result = result.model_dump()
-    del result["details"]["card_cvc"]
-    result["details"]["card_last_four"] = result["details"]["card_number"][-4:]
-    del result["details"]["card_number"]
-
-    return PaymentMethodInDB(**result)
-
-
-async def delete_payment_method(id: str, session: AsyncSession):
-    """Deletes a payment method"""
-    payment_method = await get_payment_method(id, session)
-    if not payment_method:
-        raise HTTPException(
-            status_code=404,
-            detail="Payment method not found",
-        )
-    payment_method = await session.execute(
-        select(PaymentMethod).filter(PaymentMethod.id == id)
-    )
-    payment_method = payment_method.scalars().first()
-    await session.delete(payment_method)
-    await session.commit()

api/v1/routes/account_routes.py

@@ -49,8 +49,12 @@ async def connected_account(
                 data, background_tasks=background_tasks
             )
             data_response = await create_connected_account(
-                data, session, validated_developer
+                data,
+                session,
+                validated_developer,
+                background_tasks=background_tasks,
             )
+
             onboarding_url = data_response["onboarding_url"]
             del data_response["onboarding_url"]
             links = {

api/v1/routes/payment_method_routes.py

@@ -2,131 +2,39 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from models.payment_method_model import PaymentMethod
 from fastapi import HTTPException
+from fastapi.background import BackgroundTasks
 from sqlalchemy.future import select
 from sqlalchemy import func
 from typing import Annotated
-from ..crud.payment_method_crud import (
-    create_payment_method,
-    get_payment_methods,
-    get_payment_method,
-    delete_payment_method,
-)
-from utils import validate_developer, validate_user
-from ..schema.payment_method_schema import (
-    PaymentMethodCreate,
-    PaymentMethodInDB,
-    PaymentMethodReturnDetail,
-    PaymentMethodReturnListing,
-    ListingLink,
-    ListingMeta,
-)
+from utils import validate_developer, validate_user, validate_app
 from db.session import get_db
+from ..crud.payment_method_crud import create_payment_method
+from ..schema.payment_method_schema import PaymentMethodReturnDetail
 
 router = APIRouter(prefix="/api/v1", tags=["Payment Methods"])
 
 
-@router.post(
-    "/payment-methods",
-    response_model=PaymentMethodReturnDetail,
-    status_code=201,
-)
+@router.post("/payment-methods", status_code=201)
 async def add_payment_method(
-    request: Request,
-    payment_method: PaymentMethodCreate,
+    data: Request,
+    background_tasks: BackgroundTasks,
     session: AsyncSession = Depends(get_db),
 ):
-    """Creates a new payment method"""
-    data = await create_payment_method(payment_method, session=session)
-    self_link = str(request.url_for("retrieve_payment_method", id=data.id))
-    return {
-        "data": data,
-        "meta": {
-            "message": "Payment method created successfully",
-            "status_code": 201,
-        },
-        "links": {
-            "self": self_link,
-        },
-    }
-
-
-@router.get("/payment-methods", response_model=PaymentMethodReturnListing)
-async def retrieve_payment_methods(
-    page: Annotated[int, Query(ge=1)] = 1,
-    per_page: Annotated[int, Query(ge=1, le=100)] = 20,
-    session: AsyncSession = Depends(get_db),
-    request: Request = None,
-):
-    """Retrieve all user"""
-    offset = (page - 1) * per_page
-    total_items_result = await session.execute(
-        select(func.count()).select_from(PaymentMethod)
+    """Adds a new payment method"""
+    validated_developer = await validate_developer(
+        data, background_tasks=background_tasks
     )
-    total_items = total_items_result.scalar() if total_items_result else 0
-
-    if total_items == 0:
-        raise HTTPException(
-            status_code=404,
-            detail="No payment methods found",
-        )
-    total_pages = (total_items + per_page - 1) // per_page
-
-    data = await get_payment_methods(session=session, limit=per_page, offset=offset)
-
-    base_url = str(request.url).split("?")[0]
-
-    links = ListingLink(
-        prev=f"{base_url}?page={page - 1}&per_page={per_page}" if page > 1 else None,
-        self=f"{base_url}?page={page}&per_page={per_page}",
-        next=(
-            f"{base_url}?page={page + 1}&per_page={per_page}"
-            if page < total_pages
-            else None
-        ),
-        first=f"{base_url}?page=1&per_page={per_page}",
-        last=f"{base_url}?page={total_pages}&per_page={per_page}",
+    validated_user = await validate_user(data, background_tasks=background_tasks)
+    validated_app = await validate_app(data, background_tasks=background_tasks)
+    payment_method = await create_payment_method(
+        data=data,
+        session=session,
+        validated_app=validated_app,
+        validated_developer=validated_developer,
+        validated_user=validated_user,
     )
-    meta = ListingMeta(
-        message="Payment methods retrieved successfully",
-        status_code=200,
-        page=page,
-        per_page=per_page,
-        total_pages=total_pages,
-        total_items=total_items,
+    return PaymentMethodReturnDetail(
+        links={"self": str(data.url)},
+        data=payment_method,
+        meta={"status_code": 201},
     )
-
-    return PaymentMethodReturnListing(links=links, meta=meta, data=data)
-
-
-@router.get("/payment-methods/{id}", response_model=PaymentMethodReturnDetail)
-async def retrieve_payment_method(
-    request: Request,
-    id: str,
-    session: AsyncSession = Depends(get_db),
-):
-    """Retrieves a payment method"""
-    data = await get_payment_method(id=id, session=session)
-    self_link = str(request.url_for("retrieve_payment_method", id=data.id))
-    return {
-        "data": data,
-        "meta": {
-            "message": "Payment method retrieved successfully",
-            "status_code": 200,
-        },
-        "links": {
-            "self": self_link,
-        },
-    }
-
-
-@router.delete("/payment-methods/{id}")
-async def remove_payment_method(
-    id: str,
-    session: AsyncSession = Depends(get_db),
-):
-    """Deletes a payment method"""
-    await delete_payment_method(id=id, session=session)
-    return {
-        "message": "Payment method deleted successfully",
-        "status_code": 200,
-    }