testing deployment

.gitignore

@@ -1,2 +1,3 @@
 *.pyc
-*sqlite3*
+*sqlite3*
+.vercel

App/.gitignore

@@ -0,0 +1 @@
+.vercel

App/Payments/Model.py

@@ -0,0 +1,68 @@
+from tortoise import fields
+from tortoise.models import Model
+import datetime
+from decimal import Decimal
+from App.Users.Model import User
+from App.Plans.Model import Plan
+from App.Subscriptions.Model import Subscription
+from .Schema import PaymentMethod
+
+
+class Payment(Model):
+    id = fields.UUIDField(pk=True)
+    user = fields.ForeignKeyField("models.User", related_name="payments", null=True)
+    plan = fields.ForeignKeyField(
+        "models.Plan",
+        related_name="payments",
+        null=True,
+        description="Plan associated with the payment",
+    )
+    amount = fields.DecimalField(
+        max_digits=10, decimal_places=2, description="Payment amount"
+    )
+    status = fields.CharField(
+        max_length=50,
+        default="pending",
+        description="Payment status (e.g., pending, completed, failed, balance-assigned)",
+    )
+    payment_method = fields.CharField(
+        max_length=50, choices=PaymentMethod.CHOICES, description="Payment method"
+    )
+    transaction_id = fields.CharField(
+        max_length=100,
+        unique=True,
+        null=True,
+        description="Unique transaction ID for payment (for methods like Lipa Number)",
+    )
+    created_time = fields.DatetimeField(auto_now_add=True)
+    updated_time = fields.DatetimeField(auto_now=True)
+
+    class Meta:
+        table = "payments"
+
+    async def create_subscription_if_cash(self):
+        """
+        Creates a subscription for the user if the payment method is 'cash'
+        and the user has enough balance for the specified plan.
+        """
+        if self.payment_method == PaymentMethod.CASH and self.user and self.plan:
+            if self.amount >= self.plan.amount:
+                expiration_time = datetime.datetime.now() + datetime.timedelta(
+                    hours=self.plan.duration
+                )
+
+                # Create the subscription
+                await Subscription.create(
+                    user=self.user,
+                    duration=self.plan.duration,
+                    download_mb=self.plan.download_speed
+                    * 1024,  # Converting Mbps to MB
+                    upload_mb=self.plan.upload_speed * 1024,  # Converting Mbps to MB
+                    created_time=datetime.datetime.now(),
+                    expiration_time=expiration_time,
+                    active=True,
+                )
+                self.status = "subscription-created"
+            else:
+                self.status = "insufficient-funds"
+            await self.save()

App/Payments/PaymentsRoutes.py

@@ -0,0 +1,147 @@
+from fastapi import APIRouter, HTTPException, status
+from typing import List
+from .Model import Payment
+from App.Users.Model import User
+from App.Plans.Model import Plan
+from .Schema import (
+    CreatePaymentRequest,
+    UpdatePaymentStatusRequest,
+    PaymentResponse,
+    UpdatePaymentUserRequest,
+    BaseResponse,
+    PaymentListResponse,
+)
+from .Schema import PaymentMethod
+
+payment_router = APIRouter(tags=["Payments"])
+
+
+@payment_router.post("/payment/create", response_model=BaseResponse)
+async def create_payment(request: CreatePaymentRequest):
+    # If payment method is "Lipa Number", transaction_id is required
+    if (
+        request.payment_method == PaymentMethod.LIPA_NUMBER
+        and not request.transaction_id
+    ):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Transaction ID is required for Lipa Number payments",
+        )
+
+    # Check if plan exists
+    plan = await Plan.get_or_none(id=request.plan_id)
+    if request.plan_id and not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Plan not found"
+        )
+
+    # Create new payment without linking a user initially
+    payment = await Payment.create(
+        user_id=request.user_id,
+        plan=plan,
+        amount=request.amount,
+        payment_method=request.payment_method,
+        transaction_id=request.transaction_id,
+        status="pending",  # Default status
+    )
+
+    # If payment method is "cash", attempt to create a subscription
+    if payment.payment_method == PaymentMethod.CASH:
+        await payment.create_subscription_if_cash()
+
+    await payment.save()
+
+    return BaseResponse(
+        code=200,
+        message="Payment created successfully",
+        payload={"payment_id": str(payment.id)},
+    )
+
+
+@payment_router.get("/payment/{payment_id}", response_model=PaymentResponse)
+async def get_payment(payment_id: str):
+    payment = await Payment.get_or_none(id=payment_id)
+    if not payment:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Payment not found"
+        )
+
+    return PaymentResponse(
+        id=str(payment.id),
+        user_id=payment.user_id,
+        plan_id=payment.plan_id,
+        amount=payment.amount,
+        payment_method=payment.payment_method,
+        status=payment.status,
+        transaction_id=payment.transaction_id,
+        created_time=payment.created_time,
+        updated_time=payment.updated_time,
+    )
+
+
+@payment_router.get("/payments/unlinked", response_model=PaymentListResponse)
+async def get_unlinked_payments():
+    unlinked_payments = await Payment.filter(user_id=None)
+    result = [
+        PaymentResponse(
+            id=str(payment.id),
+            user_id=payment.user_id,
+            plan_id=payment.plan_id,
+            amount=payment.amount,
+            payment_method=payment.payment_method,
+            status=payment.status,
+            transaction_id=payment.transaction_id,
+            created_time=payment.created_time,
+            updated_time=payment.updated_time,
+        )
+        for payment in unlinked_payments
+    ]
+
+    return PaymentListResponse(payments=result, total_count=len(result))
+
+
+@payment_router.put("/payment/{payment_id}/link-user", response_model=BaseResponse)
+async def link_user_to_payment(payment_id: str, request: UpdatePaymentUserRequest):
+    payment = await Payment.get_or_none(id=payment_id)
+    if not payment:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Payment not found"
+        )
+
+    user = await User.get_or_none(id=request.user_id)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="User not found"
+        )
+
+    # Link payment to the user
+    payment.user_id = request.user_id
+    await payment.save()
+
+    # If the payment method is "Lipa Number" or "M-Pesa", add to user's balance directly
+    if (
+        payment.payment_method in [PaymentMethod.LIPA_NUMBER, PaymentMethod.MPESA]
+        and not payment.plan
+    ):
+        user.balance += payment.amount
+        await user.save()
+
+        # Update payment status to indicate it was assigned to balance
+        payment.status = "balance-assigned"
+        await payment.save()
+
+        return BaseResponse(
+            code=200,
+            message="Payment linked to user and amount added to balance successfully",
+            payload={
+                "payment_id": str(payment.id),
+                "user_id": request.user_id,
+                "new_balance": user.balance,
+            },
+        )
+
+    return BaseResponse(
+        code=200,
+        message="Payment linked to user successfully",
+        payload={"payment_id": str(payment.id), "user_id": request.user_id},
+    )

App/Payments/Schema.py

@@ -0,0 +1,70 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from decimal import Decimal
+from datetime import datetime
+
+
+class BaseResponse(BaseModel):
+    code: int
+    message: str
+    payload: Optional[dict] = None
+
+
+class PaymentMethod:
+    CASH = "cash"
+    MPESA = "mpesa"
+    LIPA_NUMBER = "lipa_number"
+    CREDIT_CARD = "credit_card"
+
+    CHOICES = [CASH, MPESA, LIPA_NUMBER, CREDIT_CARD]
+
+
+class CreatePaymentRequest(BaseModel):
+    user_id: Optional[str] = Field(
+        None, description="ID of the user making the payment"
+    )
+    plan_id: Optional[str] = Field(
+        None, description="ID of the plan associated with the payment"
+    )
+    amount: Decimal = Field(..., description="Payment amount")
+    payment_method: str = Field(
+        ..., description="Method of payment", example=PaymentMethod.CASH
+    )
+    transaction_id: Optional[str] = Field(
+        None, description="Unique transaction ID (for methods like Lipa Number)"
+    )
+
+
+class UpdatePaymentStatusRequest(BaseModel):
+    status: str = Field(
+        ..., description="Status of the payment (e.g., pending, completed, failed)"
+    )
+
+
+class PaymentResponse(BaseModel):
+    id: str
+    user_id: Optional[str]
+    plan_id: Optional[str]
+    amount: Decimal
+    payment_method: str
+    status: str
+    transaction_id: Optional[str]
+    created_time: datetime
+    updated_time: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class PaymentListResponse(BaseModel):
+    payments: List[PaymentResponse]
+    total_count: int
+
+    class Config:
+        from_attributes = True
+
+
+class UpdatePaymentUserRequest(BaseModel):
+    user_id: str = Field(
+        ..., description="ID of the user to link or update for this payment"
+    )

App/Plans/Model.py

@@ -0,0 +1,18 @@
+from tortoise import fields
+from tortoise.models import Model
+
+
+class Plan(Model):
+    id = fields.UUIDField(pk=True)
+    name = fields.CharField(
+        max_length=100, unique=True, description="Name of the subscription plan"
+    )
+    amount = fields.DecimalField(
+        max_digits=10, decimal_places=2, description="Cost of the plan"
+    )
+    duration = fields.IntField(description="Duration of the subscription in hours")
+    download_speed = fields.FloatField(description="Download speed in Mbps")
+    upload_speed = fields.FloatField(description="Upload speed in Mbps")
+
+    class Meta:
+        table = "plans"

App/Plans/PlanRoutes.py

@@ -0,0 +1,99 @@
+from fastapi import APIRouter, HTTPException, status, Depends
+from typing import List
+from .Model import Plan
+from .Schema import (
+    CreatePlanRequest,
+    UpdatePlanRequest,
+    PlanResponse,
+    PlanListResponse,
+    BaseResponse,
+)
+
+plan_router = APIRouter(tags=["Plans"])
+
+
+@plan_router.post("/plan/create", response_model=BaseResponse)
+async def create_plan(request: CreatePlanRequest):
+    # Check if a plan with the same name already exists
+    existing_plan = await Plan.get_or_none(name=request.name)
+    if existing_plan:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="A plan with this name already exists",
+        )
+
+    # Create a new plan
+    plan = await Plan.create(
+        name=request.name,
+        amount=request.amount,
+        duration=request.duration,
+        download_speed=request.download_speed,
+        upload_speed=request.upload_speed,
+    )
+    await plan.save()
+
+    return BaseResponse(
+        code=200, message="Plan created successfully", payload={"plan_id": str(plan.id)}
+    )
+
+
+@plan_router.put("/plan/{plan_id}/update", response_model=BaseResponse)
+async def update_plan(plan_id: str, request: UpdatePlanRequest):
+    # Find the plan by ID
+    plan = await Plan.get_or_none(id=plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Plan not found"
+        )
+
+    # Update the plan fields if provided
+    if request.name is not None:
+        plan.name = request.name
+    if request.amount is not None:
+        plan.amount = request.amount
+    if request.duration is not None:
+        plan.duration = request.duration
+    if request.download_speed is not None:
+        plan.download_speed = request.download_speed
+    if request.upload_speed is not None:
+        plan.upload_speed = request.upload_speed
+
+    await plan.save()
+
+    return BaseResponse(
+        code=200, message="Plan updated successfully", payload={"plan_id": str(plan.id)}
+    )
+
+
+@plan_router.delete("/plan/{plan_id}/delete", response_model=BaseResponse)
+async def delete_plan(plan_id: str):
+    # Find the plan by ID
+    plan = await Plan.get_or_none(id=plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Plan not found"
+        )
+
+    await plan.delete()
+
+    return BaseResponse(code=200, message="Plan deleted successfully")
+
+
+@plan_router.get("/plans", response_model=PlanListResponse)
+async def list_plans():
+    plans = await Plan.all()
+    total_count = await Plan.all().count()
+
+    result = [
+        PlanResponse(
+            id=str(plan.id),
+            name=plan.name,
+            amount=plan.amount,
+            duration=plan.duration,
+            download_speed=plan.download_speed,
+            upload_speed=plan.upload_speed,
+        )
+        for plan in plans
+    ]
+
+    return PlanListResponse(plans=result, total_count=total_count)

App/Plans/Schema.py

@@ -0,0 +1,47 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from decimal import Decimal
+
+
+class BaseResponse(BaseModel):
+    code: int
+    message: str
+    payload: Optional[dict] = None
+
+
+class CreatePlanRequest(BaseModel):
+    name: str = Field(..., description="Name of the subscription plan")
+    amount: Decimal = Field(..., description="Cost of the plan")
+    duration: int = Field(..., description="Duration of the subscription in hours")
+    download_speed: float = Field(..., description="Download speed in Mbps")
+    upload_speed: float = Field(..., description="Upload speed in Mbps")
+
+
+class UpdatePlanRequest(BaseModel):
+    name: Optional[str] = Field(None, description="Name of the subscription plan")
+    amount: Optional[Decimal] = Field(None, description="Cost of the plan")
+    duration: Optional[int] = Field(
+        None, description="Duration of the subscription in hours"
+    )
+    download_speed: Optional[float] = Field(None, description="Download speed in Mbps")
+    upload_speed: Optional[float] = Field(None, description="Upload speed in Mbps")
+
+
+class PlanResponse(BaseModel):
+    id: str
+    name: str
+    amount: Decimal
+    duration: int
+    download_speed: float
+    upload_speed: float
+
+    class Config:
+        from_attributes = True
+
+
+class PlanListResponse(BaseModel):
+    plans: List[PlanResponse]
+    total_count: int
+
+    class Config:
+        from_attributes = True

App/Portals/Model.py

@@ -0,0 +1,24 @@
+from tortoise import fields, models
+
+
+class Portal(models.Model):
+    id = fields.IntField(pk=True)
+    name = fields.CharField(
+        max_length=50,
+        unique=True,
+        description="Name of the portal, e.g., Android or MikroTik",
+    )
+    description = fields.CharField(
+        max_length=255,
+        description="Description of the portal",
+    )
+    url = fields.CharField(
+        max_length=255,
+        description="URL of the portal, must start with http or https",
+    )
+
+    class Meta:
+        table = "portals"
+
+    def __str__(self):
+        return f"{self.name} - {self.url}"

App/Portals/PortalRoutes.py

@@ -0,0 +1,82 @@
+from fastapi import APIRouter, HTTPException, status
+from .Schema import (
+    CreatePortalRequest,
+    UpdatePortalRequest,
+    PortalResponse,
+    BaseResponse,
+)
+from .Model import Portal
+
+portal_router = APIRouter(tags=["Portals"])
+
+# Constants for portal names
+ANDROID = "Android"
+MIKROTIK = "MikroTik"
+
+
+# Get Portal by Name (Android or MikroTik)
+@portal_router.get(
+    "/portals/{portal_name}",
+    response_model=PortalResponse,
+    status_code=status.HTTP_200_OK,
+)
+async def get_portal_by_name(portal_name: str):
+    portal = await Portal.get_or_none(name=portal_name)
+    if not portal:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Portal '{portal_name}' not found.",
+        )
+
+    return PortalResponse.from_orm(portal)
+
+
+# Assign or Update Android Portal
+@portal_router.put(
+    "/portals/android", response_model=BaseResponse, status_code=status.HTTP_200_OK
+)
+async def update_android_portal(request: UpdatePortalRequest):
+
+    try:
+        portal, created = await Portal.get_or_create(name=ANDROID)
+    except:
+        portal, created = await Portal.get_or_create(
+            name=ANDROID, description="Android-Link", url="https://example.com"
+        )
+
+    portal_data = request.dict(exclude_unset=True)
+    for key, value in portal_data.items():
+        setattr(portal, key, value)
+
+    await portal.save()
+    message = (
+        "Android portal created successfully"
+        if created
+        else "Android portal updated successfully"
+    )
+    return BaseResponse(code=200, message=message, payload={"portal_name": ANDROID})
+
+
+# Assign or Update MikroTik Portal
+@portal_router.put(
+    "/portals/mikrotik", response_model=BaseResponse, status_code=status.HTTP_200_OK
+)
+async def update_mikrotik_portal(request: UpdatePortalRequest):
+    try:
+        portal, created = await Portal.get_or_create(name=MIKROTIK)
+    except:
+        portal, created = await Portal.get_or_create(
+            name=MIKROTIK, description="Android-Link", url="https://example.com"
+        )
+
+    portal_data = request.dict(exclude_unset=True)
+    for key, value in portal_data.items():
+        setattr(portal, key, value)
+
+    await portal.save()
+    message = (
+        "MikroTik portal created successfully"
+        if created
+        else "MikroTik portal updated successfully"
+    )
+    return BaseResponse(code=200, message=message, payload={"portal_name": MIKROTIK})

App/Portals/Schema.py

@@ -0,0 +1,56 @@
+from pydantic import BaseModel, Field, HttpUrl
+from typing import List, Optional
+
+
+class BaseResponse(BaseModel):
+    code: int
+    message: str
+    payload: Optional[dict] = None
+
+
+# Create Portal Request
+class CreatePortalRequest(BaseModel):
+    name: str = Field(
+        ..., max_length=50, description="Name of the portal, e.g., Android or MikroTik"
+    )
+    description: str = Field(
+        ..., max_length=255, description="Description of the portal"
+    )
+    url: HttpUrl = Field(..., description="URL of the portal")
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "name": "Android",
+                "description": "Official Android developer portal",
+                "url": "https://developer.android.com",
+            }
+        }
+
+
+# Update Portal Request
+class UpdatePortalRequest(BaseModel):
+    description: Optional[str] = Field(
+        None, max_length=255, description="Updated description of the portal"
+    )
+    url: Optional[HttpUrl] = Field(None, description="Updated URL of the portal")
+
+
+# Portal Response
+class PortalResponse(BaseModel):
+    id: int
+    name: str
+    description: str
+    url: HttpUrl
+
+    class Config:
+        orm_mode = True
+
+
+# List of Portals Response
+class PortalListResponse(BaseModel):
+    portals: List[PortalResponse]
+    total_count: int
+
+    class Config:
+        orm_mode = True

App/Subscriptions/BackgroundTask.py

@@ -0,0 +1,21 @@
+import asyncio
+from datetime import datetime
+from .Model import Subscription
+
+
+async def deactivate_expired_subscriptions():
+    while True:
+        # Find active subscriptions that have expired
+        expired_subscriptions = await Subscription.filter(
+            active=True, expiration_time__lt=datetime.now()
+        )
+
+        # Deactivate all expired subscriptions
+        for subscription in expired_subscriptions:
+            subscription.active = False
+            await subscription.save()
+
+        # Deactivate the user if he has no plans
+
+        # Run this check every hour (or adjust as needed)
+        await asyncio.sleep(60)  # 1 hour

App/Subscriptions/Model.py

@@ -0,0 +1,67 @@
+from tortoise import fields
+from tortoise.models import Model
+import datetime
+from App.Users.Model import User
+from App.Plans.Model import Plan
+
+
+class Subscription(Model):
+    id = fields.UUIDField(pk=True)
+    user = fields.ForeignKeyField("models.User", related_name="subscriptions")
+    plan = fields.ForeignKeyField(
+        "models.Plan",
+        related_name="subscriptions",
+        null=True,
+        description="Plan associated with the subscription",
+    )
+    active = fields.BooleanField(default=True)
+    duration = fields.IntField(description="Duration in hours")
+    download_mb = fields.FloatField(
+        default=0.0, description="Download usage in megabytes"
+    )
+    upload_mb = fields.FloatField(default=0.0, description="Upload usage in megabytes")
+    created_time = fields.DatetimeField(auto_now_add=True)
+    expiration_time = fields.DatetimeField(null=True)
+
+    class Meta:
+        table = "subscriptions"
+
+    async def save(self, *args, **kwargs):
+        # Calculate expiration_time if it's not set and we have created_time and duration
+        if not self.expiration_time and self.created_time and self.duration:
+            self.expiration_time = self.created_time + datetime.timedelta(
+                hours=self.duration
+            )
+        await super().save(*args, **kwargs)
+
+    async def time_remaining(self) -> float:
+        """
+        Calculate the remaining time for the subscription in hours.
+        Returns:
+            float: Number of hours remaining. Returns 0 if subscription has expired.
+        """
+        if not self.active:
+            return 0.0
+
+        current_time = datetime.datetime.now(self.created_time.tzinfo)
+
+        # If subscription has expired, deactivate it
+        if current_time >= self.expiration_time:
+            self.active = False
+            await self.save()
+            return 0.0
+
+        # Calculate remaining time in hours
+        time_diff = self.expiration_time - current_time
+        remaining_hours = time_diff.total_seconds() / 3600
+
+        return round(remaining_hours, 2)
+
+    async def is_valid(self) -> bool:
+        """
+        Check if the subscription is still valid (active and not expired).
+        Returns:
+            bool: True if subscription is valid, False otherwise.
+        """
+        remaining_time = await self.time_remaining()
+        return self.active and remaining_time > 0

App/Subscriptions/Schema.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from datetime import datetime
+
+
+class BaseResponse(BaseModel):
+    code: int
+    message: str
+    payload: Optional[dict] = None
+
+
+class CreateSubscriptionRequest(BaseModel):
+    user_id: str = Field(..., description="ID of the user to create subscription for")
+    plan_id: str = Field(..., description="ID of the plan to base the subscription on")
+
+
+class UpdateUsageRequest(BaseModel):
+    download_mb: float = Field(0.0, ge=0, description="Download usage in megabytes")
+    upload_mb: float = Field(0.0, ge=0, description="Upload usage in megabytes")
+
+
+class SubscriptionResponse(BaseModel):
+    id: str
+    user_id: str
+    plan_id: Optional[str]
+    active: bool
+    duration: int
+    download_mb: float
+    upload_mb: float
+    remaining_hours: float
+    created_time: datetime
+    expiration_time: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class SubscriptionListResponse(BaseModel):
+    subscriptions: List[SubscriptionResponse]
+    total_count: int
+
+    class Config:
+        from_attributes = True

App/Subscriptions/SubscriptionRoutes.py

@@ -0,0 +1,156 @@
+from fastapi import APIRouter, HTTPException, status, Depends
+from typing import List
+from datetime import datetime
+from .Model import Subscription
+from App.Users.Model import User
+from App.Plans.Model import Plan
+from .Schema import (
+    CreateSubscriptionRequest,
+    SubscriptionResponse,
+    BaseResponse,
+    UpdateUsageRequest,
+    SubscriptionListResponse,
+)
+
+subscription_router = APIRouter(tags=["Subscriptions"])
+
+
+@subscription_router.post("/subscription/create", response_model=BaseResponse)
+async def create_subscription(request: CreateSubscriptionRequest):
+    # Check if user exists
+    user = await User.get_or_none(id=request.user_id)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="User not found"
+        )
+
+    # Check if plan exists
+    plan = await Plan.get_or_none(id=request.plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Plan not found"
+        )
+
+    # Create new subscription based on plan details
+    expiration_time = datetime.datetime.now() + datetime.timedelta(hours=plan.duration)
+    subscription = await Subscription.create(
+        user=user,
+        plan=plan,
+        duration=plan.duration,
+        download_mb=plan.download_speed * 1024,  # Converting Mbps to MB
+        upload_mb=plan.upload_speed * 1024,  # Converting Mbps to MB
+        expiration_time=expiration_time,
+        active=True,
+    )
+    await subscription.save()
+
+    return BaseResponse(
+        code=200,
+        message="Subscription created successfully",
+        payload={"subscription_id": str(subscription.id)},
+    )
+
+
+@subscription_router.get(
+    "/subscription/{subscription_id}", response_model=SubscriptionResponse
+)
+async def get_subscription(subscription_id: str):
+    subscription = await Subscription.get_or_none(id=subscription_id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Subscription not found"
+        )
+
+    remaining_hours = await subscription.time_remaining()
+
+    return SubscriptionResponse(
+        id=str(subscription.id),
+        user_id=subscription.user_id,
+        plan_id=subscription.plan_id,
+        active=subscription.active,
+        duration=subscription.duration,
+        download_mb=subscription.download_mb,
+        upload_mb=subscription.upload_mb,
+        remaining_hours=remaining_hours,
+        created_time=subscription.created_time,
+        expiration_time=subscription.expiration_time,
+    )
+
+
+@subscription_router.get(
+    "/subscription/user/{user_id}", response_model=List[SubscriptionResponse]
+)
+async def get_user_subscriptions(user_id: str):
+    user = await User.get_or_none(id=user_id)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="User not found"
+        )
+
+    subscriptions = await Subscription.filter(user_id=user_id)
+    result = []
+
+    for subscription in subscriptions:
+        remaining_hours = await subscription.time_remaining()
+        result.append(
+            SubscriptionResponse(
+                id=str(subscription.id),
+                user_id=subscription.user_id,
+                plan_id=subscription.plan_id,
+                active=subscription.active,
+                duration=subscription.duration,
+                download_mb=subscription.download_mb,
+                upload_mb=subscription.upload_mb,
+                remaining_hours=remaining_hours,
+                created_time=subscription.created_time,
+                expiration_time=subscription.expiration_time,
+            )
+        )
+
+    return result
+
+
+@subscription_router.put(
+    "/subscription/{subscription_id}/update-usage", response_model=BaseResponse
+)
+async def update_usage(subscription_id: str, request: UpdateUsageRequest):
+    subscription = await Subscription.get_or_none(id=subscription_id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Subscription not found"
+        )
+
+    if not await subscription.is_valid():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Subscription is not active or has expired",
+        )
+
+    subscription.download_mb += request.download_mb
+    subscription.upload_mb += request.upload_mb
+    await subscription.save()
+
+    return BaseResponse(
+        code=200,
+        message="Usage updated successfully",
+        payload={
+            "total_download_mb": subscription.download_mb,
+            "total_upload_mb": subscription.upload_mb,
+        },
+    )
+
+
+@subscription_router.post(
+    "/subscription/{subscription_id}/deactivate", response_model=BaseResponse
+)
+async def deactivate_subscription(subscription_id: str):
+    subscription = await Subscription.get_or_none(id=subscription_id)
+    if not subscription:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Subscription not found"
+        )
+
+    subscription.active = False
+    await subscription.save()
+
+    return BaseResponse(code=200, message="Subscription deactivated successfully")

App/Users/Model.py

@@ -1,76 +1,75 @@
-import asyncio
-import uuid
-from tortoise import fields, Tortoise
-from tortoise.models import Model
+from tortoise import fields, models
 from passlib.context import CryptContext
 import datetime
+import uuid
 import random
 import string
+
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
+
 def generate_short_uuid() -> str:
-    """Generate a random 5-character alphanumeric string."""
-    return ''.join(random.choices(string.ascii_letters + string.digits, k=5))
+    return "".join(random.choices(string.ascii_letters + string.digits, k=5))
 
 
-class User(Model):
+class User(models.Model):
     id = fields.CharField(primary_key=True, max_length=5, default=generate_short_uuid)
-    name = fields.CharField(max_length=100, db_index=True)
-    email = fields.CharField(max_length=100, db_index=True, unique=True)
+    name = fields.CharField(max_length=100)
     password = fields.CharField(max_length=100)
-    phoneNumber = fields.CharField(max_length=100, null=True)
-    account_type = fields.IntField(default=1)
+    phoneNumber = fields.CharField(max_length=15, unique=True)
     balance = fields.DecimalField(max_digits=10, decimal_places=2, default=0.00)
-    ip_address = fields.CharField(max_length=45, null=True)
-    mac_address = fields.CharField(max_length=17, null=True)
-    createdAt = fields.DatetimeField(default=datetime.datetime.now)
-    updatedAt = fields.DatetimeField(default=datetime.datetime.now)
+    mac_address = fields.CharField(max_length=17)
+    createdAt = fields.DatetimeField(auto_now_add=True)
+    updatedAt = fields.DatetimeField(auto_now=True)
     lastLogin = fields.DatetimeField(default=datetime.datetime.now)
     failed_attempts = fields.IntField(default=0)
     account_locked = fields.BooleanField(default=False)
-    reset_token = fields.CharField(max_length=100, null=True, unique=True)
+    reset_token = fields.CharField(max_length=6, null=True, unique=True)
     reset_token_expiration = fields.DatetimeField(null=True)
 
     class Meta:
         table = "users"
 
+    def hash_password(self, plain_password: str) -> str:
+        return pwd_context.hash(plain_password)
+
     def verify_password(self, plain_password: str) -> bool:
-        if self.account_locked:
-            print("Account is locked due to too many failed attempts.")
+        if (
+            self.account_locked
+            and datetime.datetime.now()
+            < self.lastLogin + datetime.timedelta(minutes=15)
+        ):
+            print("Account is locked due to too many failed attempts. Try again later.")
             return False
 
         if pwd_context.verify(plain_password, self.password):
-            self.failed_attempts = 0  # Reset failed attempts on success
+            self.failed_attempts = 0
             self.account_locked = False
-            self.save()  # Save changes to reset the failed attempts count
+            self.lastLogin = datetime.datetime.now()
+            self.save()
             return True
         else:
             self.failed_attempts += 1
             if self.failed_attempts >= 5:
                 self.account_locked = True
-                print("Account locked due to too many failed attempts.")
-            self.save()  # Save changes to update the failed attempts count
+            self.save()
             return False
 
     async def initiate_password_reset(self):
-        # Generate a unique reset token
-        self.reset_token = str(uuid.uuid4())
-        self.reset_token_expiration = datetime.datetime.now() + datetime.timedelta(hours=1)  # Token expires in 1 hour
+        self.reset_token = f"{random.randint(100000, 999999)}"
+        self.reset_token_expiration = datetime.datetime.now() + datetime.timedelta(
+            minutes=15
+        )
         await self.save()
 
-        # In a real application, send this token to the user's email or phone
-        print(f"Password reset token for {self.email}: {self.reset_token}")
-
-    async def reset_password(self, reset_token, new_password):
-        # Check if the reset token is valid and not expired
-        if self.reset_token != reset_token or datetime.datetime.now() > self.reset_token_expiration:
-            print("Invalid or expired reset token.")
+    async def reset_password(self, reset_token: str, new_password: str):
+        if (
+            self.reset_token != reset_token
+            or datetime.datetime.now() > self.reset_token_expiration
+        ):
             return False
-
-        # Set the new password
-        self.password = pwd_context.hash(new_password)
-        self.reset_token = None  # Clear the token after successful reset
+        self.password = self.hash_password(new_password)
+        self.reset_token = None
         self.reset_token_expiration = None
         await self.save()
-        print("Password has been reset successfully.")
-        return True
+        return True

App/Users/{Schemas.py → Schema.py}

@@ -5,45 +5,46 @@ from passlib.context import CryptContext
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
+# Constants for phone and MAC address patterns
+PHONE_PATTERN = r"^(?:\+255|0)\d{9}$"
+MAC_PATTERN = r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
+
 
 # Register User Request
 class RegisterUserRequest(BaseModel):
     name: str = Field(..., max_length=100)
-    email: str = Field(..., max_length=100)
-    password: constr(min_length=8)
-    phoneNumber: str = Field(..., max_length=15)
-    mac_address: str = Field(..., max_length=17)  # Standard MAC address format
+    password: str = Field(..., max_length=100)
+    phoneNumber: str = Field(
+        ...,
+        pattern=PHONE_PATTERN,
+        description="Tanzanian phone number starting with +255 or 0 followed by 9 digits",
+    )
+    mac_address: str = Field(
+        ..., pattern=MAC_PATTERN, description="MAC address in standard format"
+    )
+
     def hash_password(self):
         self.password = pwd_context.hash(self.password)
+
     class Config:
         schema_extra = {
             "example": {
                 "name": "John Doe",
-                "email": "[email protected]",
-                "password": "strongpassword123",
-                "phoneNumber": "1234567890",
-                "mac_address": "00:1A:2B:3C:4D:5E"
+                "password": "StrongPassword1!",
+                "phoneNumber": "+255123456789",
+                "mac_address": "00:1A:2B:3C:4D:5E",
             }
         }
 
 
-# Login User Request (using phone number and MAC address)
+# Login User Request
 class LoginUserRequest(BaseModel):
-    phoneNumber: str = Field(..., max_length=15)
-    password: constr(min_length=8)
-    mac_address: str = Field(..., max_length=17)  # Required for login
+    phoneNumber: str = Field(..., pattern=PHONE_PATTERN)
+    password: str
+    mac_address: str = Field(..., pattern=MAC_PATTERN)
 
-    class Config:
-        schema_extra = {
-            "example": {
-                "phoneNumber": "1234567890",
-                "password": "strongpassword123",
-                "mac_address": "00:1A:2B:3C:4D:5E"
-            }
-        }
 
-
-# Access Token Response (used for Login)
+# Access Token Response
 class AccessTokenResponse(BaseModel):
     access_token: str
     token_type: str = "bearer"
@@ -55,45 +56,19 @@ class BaseResponse(BaseModel):
     message: str
     payload: Optional[dict] = None
 
-# Schemas.py
-
 
-
-# Step 1: Forgot Password Request (using phone number)
+# Forgot Password Request
 class ForgotPasswordRequest(BaseModel):
-    phoneNumber: str = Field(..., max_length=15)
-
-    class Config:
-        schema_extra = {
-            "example": {
-                "phoneNumber": "1234567890"
-            }
-        }
+    phoneNumber: str = Field(..., pattern=PHONE_PATTERN)
 
 
-# Step 2a: Verify Reset Token Request
+# Verify Reset Token Request
 class VerifyResetTokenRequest(BaseModel):
-    phoneNumber: str = Field(..., max_length=15)
-    reset_token: str = Field(..., max_length=6)  # Short token
-
-    class Config:
-        schema_extra = {
-            "example": {
-                "phoneNumber": "1234567890",
-                "reset_token": "123456"
-            }
-        }
+    phoneNumber: str = Field(..., pattern=PHONE_PATTERN)
+    reset_token: str = Field(..., max_length=6)
 
 
-# Step 2b: Reset Password Request (after token verification)
+# Reset Password Request
 class ResetPasswordRequest(BaseModel):
-    phoneNumber: str = Field(..., max_length=15)
-    new_password: constr(min_length=8)
-
-    class Config:
-        schema_extra = {
-            "example": {
-                "phoneNumber": "1234567890",
-                "new_password": "newstrongpassword123"
-            }
-        }
+    phoneNumber: str = Field(..., pattern=PHONE_PATTERN)
+    new_password: str = Field(..., max_length=100)

App/Users/UserRoutes.py

@@ -1,105 +1,102 @@
 from fastapi import APIRouter, HTTPException, status
-from .Schemas import (
-    RegisterUserRequest, ResetPasswordRequest, LoginUserRequest,
-    AccessTokenResponse, BaseResponse, ForgotPasswordRequest, VerifyResetTokenRequest
+from .Schema import (
+    RegisterUserRequest,
+    LoginUserRequest,
+    AccessTokenResponse,
+    ForgotPasswordRequest,
+    VerifyResetTokenRequest,
+    ResetPasswordRequest,
+    BaseResponse,
 )
 from .Model import User
 from jose import jwt
-from datetime import datetime, timedelta,timezone
-import random
-from passlib.context import CryptContext
+from datetime import datetime, timedelta
 
-# Configurations for JWT and Password Reset
+# JWT Configurations
 SECRET_KEY = "your_secret_key_here"
 ALGORITHM = "HS256"
 ACCESS_TOKEN_EXPIRE_MINUTES = 30
-PASSWORD_RESET_EXPIRE_MINUTES = 15  # Reset token valid for 15 minutes
-
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 user_router = APIRouter(tags=["User"])
 
-# Utility function to create JWT token
+
 def create_access_token(data: dict, expires_delta: timedelta = None):
     to_encode = data.copy()
-    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES))
+    expire = datetime.utcnow() + (
+        expires_delta or timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
     to_encode.update({"exp": expire})
     return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
 
-# Register route
-@user_router.post("/user/register", response_model=BaseResponse, status_code=status.HTTP_201_CREATED)
-async def register_user(user: RegisterUserRequest):
-    existing_user = await User.filter(phoneNumber=user.phoneNumber).first()
+
+@user_router.post(
+    "/user/register", response_model=BaseResponse, status_code=status.HTTP_201_CREATED
+)
+async def register_user(request: RegisterUserRequest):
+    existing_user = await User.filter(phoneNumber=request.phoneNumber).first()
     if existing_user:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="User already exists.")
-    user.hash_password()
-    
-    new_user = await User.create(**user.dict())
-    return BaseResponse(code=200, message="User created successfully", payload={"user_id": new_user.id})
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="User already exists."
+        )
+    request.hash_password()
+    new_user = await User.create(**request.dict())
+    return BaseResponse(
+        code=200, message="User created successfully", payload={"user_id": new_user.id}
+    )
 
-# Login route (using phone number)
-@user_router.post("/user/login", response_model=AccessTokenResponse, status_code=status.HTTP_200_OK)
-async def login_user(user: LoginUserRequest):
-    db_user = await User.filter(phoneNumber=user.phoneNumber).first()
-    if db_user and db_user.verify_password(user.password):
+
+@user_router.post(
+    "/user/login", response_model=AccessTokenResponse, status_code=status.HTTP_200_OK
+)
+async def login_user(request: LoginUserRequest):
+    db_user = await User.filter(phoneNumber=request.phoneNumber).first()
+    if db_user and db_user.verify_password(request.password):
         access_token = create_access_token(data={"sub": db_user.phoneNumber})
         return AccessTokenResponse(access_token=access_token, token_type="bearer")
-    
     raise HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Invalid credentials",
-        headers={"WWW-Authenticate": "Bearer"},
+        status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials"
     )
 
-# Forgot Password route (using phone number only)
-@user_router.post("/user/forgot-password", response_model=BaseResponse, status_code=status.HTTP_200_OK)
+
+@user_router.post(
+    "/user/forgot-password", response_model=BaseResponse, status_code=status.HTTP_200_OK
+)
 async def forgot_password(request: ForgotPasswordRequest):
     user = await User.filter(phoneNumber=request.phoneNumber).first()
     if not user:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found.")
-
-    # Generate a short reset token (6-digit code)
-    reset_token = f"{random.randint(100000, 999999)}"
-    reset_token_expiration = datetime.utcnow() + timedelta(minutes=PASSWORD_RESET_EXPIRE_MINUTES)
-    
-    # Store reset token and expiration in the user record
-    user.reset_token = reset_token
-    user.reset_token_expiration = reset_token_expiration
-    await user.save()
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="User not found."
+        )
+    await user.initiate_password_reset()
+    return BaseResponse(code=200, message="Password reset token sent to your phone.")
 
-    # In production, send this token via SMS to the user's phone number
-    print(f"Password reset token for {request.phoneNumber}: {reset_token}")
 
-    return BaseResponse(code=200, message="Password reset token sent. Check your phone for further instructions.")
-
-# Verify Reset Token route
-@user_router.post("/user/verify-reset-token", response_model=BaseResponse, status_code=status.HTTP_200_OK)
+@user_router.post(
+    "/user/verify-reset-token",
+    response_model=BaseResponse,
+    status_code=status.HTTP_200_OK,
+)
 async def verify_reset_token(request: VerifyResetTokenRequest):
-    user = await User.filter(phoneNumber=request.phoneNumber, reset_token=request.reset_token).first()
-    if not user:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Invalid token or phone number.")
-
-    # Check if the reset token has expired
-    if datetime.utcnow().replace(tzinfo=timezone.utc) > user.reset_token_expiration:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Reset token has expired.")
-
-    return BaseResponse(code=200, message="Token verified. You may now reset your password.")
-
-# Reset Password route (After Token Verification)
-@user_router.post("/user/reset-password", response_model=BaseResponse, status_code=status.HTTP_200_OK)
+    user = await User.filter(
+        phoneNumber=request.phoneNumber, reset_token=request.reset_token
+    ).first()
+    if not user or datetime.utcnow() > user.reset_token_expiration:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid or expired token."
+        )
+    return BaseResponse(code=200, message="Token verified. Proceed to reset password.")
+
+
+@user_router.post(
+    "/user/reset-password", response_model=BaseResponse, status_code=status.HTTP_200_OK
+)
 async def reset_password(request: ResetPasswordRequest):
     user = await User.filter(phoneNumber=request.phoneNumber).first()
     if not user:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found.")
-
-    # Check if the reset token is present and not expired
-
-    if not user.reset_token or datetime.utcnow().replace(tzinfo=timezone.utc) > user.reset_token_expiration:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Reset token invalid or expired.")
-
-    # Update the user's password and clear the reset token
-    user.password = pwd_context.hash(request.new_password)
-    user.reset_token = None
-    user.reset_token_expiration = None
-    await user.save()
-
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="User not found."
+        )
+    if not await user.reset_password(request.reset_token, request.new_password):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid or expired token."
+        )
     return BaseResponse(code=200, message="Password has been reset successfully.")

App/app.py

@@ -2,7 +2,11 @@ from fastapi import FastAPI
 from tortoise import Tortoise, run_async
 from .Users.UserRoutes import user_router
 from .Webhooks.webhookRoute import webhook_router
+from .Subscriptions.SubscriptionRoutes import subscription_router
 from .modelInit import TORTOISE_ORM
+from .Payments.PaymentsRoutes import payment_router
+from .Plans.PlanRoutes import plan_router
+from .Portals.PortalRoutes import portal_router
 
 app = FastAPI()
 
@@ -20,10 +24,17 @@ async def landing_page():
 
 app.include_router(user_router)
 app.include_router(webhook_router)
+app.include_router(subscription_router)
+app.include_router(payment_router)
+app.include_router(plan_router)
+app.include_router(portal_router)
 
 
-async def main():
-    pass
+if __name__ == "__main__":
+    import uvicorn
+
+    # Run the FastAPI app located at App.app:app
+    uvicorn.run(app, host="0.0.0.0", port=8000)
 
 
 # if __name__ == "__main__":

App/discovery.py

@@ -1,25 +1,34 @@
-# discover_models.py
-
 import importlib
 import os
 from typing import List
 
-def discover_models(target_file: str,directory: str="./") -> List[str]:
+
+def discover_models(target_file: str, directory: str = None) -> List[str]:
     """
-    Discover target file (e.g., models.py) in all directories and subdirectories.
-    
-    :param directory: The root directory to start searching from.
+    Discover and import target files (e.g., models.py) in all directories and subdirectories.
+
     :param target_file: The filename to look for in subdirectories (e.g., "models.py").
+    :param directory: The root directory to start searching from.
+                      Defaults to the directory where this script is located.
     :return: A list of module paths as strings.
     """
+    if directory is None:
+        directory = os.path.dirname(
+            os.path.abspath(__file__)
+        )  # Use current directory of the script
+
     model_modules = []
-    
+
     # Traverse directory and subdirectories
     for root, _, files in os.walk(directory):
         if target_file in files:
-            # Construct the module path, converting file path to dot notation
+            # Construct the module path relative to the given directory
             relative_path = os.path.relpath(root, directory)
-            module_name = f"{directory.replace('/', '.')}.{relative_path.replace('/', '.')}.{target_file[:-3]}"
-            model_modules.append(module_name.replace('...',""))
-    print(model_modules)
+            module_name = os.path.join(relative_path, target_file).replace(
+                os.sep, "."
+            )  # Correct dot notation
+            module_name = module_name[:-3]  # Remove '.py' extension
+            model_modules.append(module_name)
+
+    print("Discovered models:", model_modules)
     return model_modules

App/modelInit.py

@@ -1,18 +1,39 @@
+import ssl
 from App.discovery import discover_models
-import asyncio
 
+# Set up SSL context for secure database connections
+ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+ssl_context.check_hostname = True
+ssl_context.verify_mode = ssl.CERT_REQUIRED
 
-
-DATABASE_URL = "sqlite://db.sqlite3"  # Example: SQLite for local development
+# Discover models
+models = discover_models("Model.py")
+print("Discovered models:", models)
 
 TORTOISE_ORM = {
-    "connections": {"default": DATABASE_URL},
+    "connections": {
+        "default": {
+            "engine": "tortoise.backends.asyncpg",
+            "credentials": {
+                "host": "ep-patient-darkness-a5bmmt9r.us-east-2.aws.neon.tech",
+                "port": "5432",
+                "user": "neondb_owner",
+                "password": "l2kE5dbMyqfx",
+                "database": "neondb",
+                "ssl": ssl_context,  # Pass the SSL context here
+            },
+        }
+    },
     "apps": {
         "models": {
-            "models": discover_models("Model.py"),  # Automatically discover models in the "models" directory
+            "models": [
+                "App.Payments.Model",
+                "App.Plans.Model",
+                "App.Portals.Model",
+                "App.Subscriptions.Model",
+                "App.Users.Model",
+            ],
             "default_connection": "default",
         }
     },
 }
-
-

App/requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+passlib
+pydantic[email]
+uvicorn
+python-jose
+bcrypt
+httpx
+pytest
+tortoise-orm

App/vercel.json

@@ -0,0 +1,15 @@
+{
+  "builds": [
+    {
+      "src": "App/app.py",
+      "use": "@vercel/python",
+      "runtime": "python3.10"
+    }
+  ],
+  "routes": [
+    {
+      "src": "/(.*)",
+      "dest": "App/app.py"
+    }
+  ]
+}

Dockerfile

@@ -1,7 +1,18 @@
-FROM python:3.8.13
-WORKDIR /usr/src/nginx
-COPY . .
+# Use an official Python image as a base
+FROM python:3.10-slim
 
-RUN python3 -m pip install -r requirements.txt 
-CMD  uvicorn App.app:app --host 0.0.0.0 --workers 4
-EXPOSE 8000
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the application files to the container
+COPY . /app
+
+# Install dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Expose the port the app runs on
+EXPOSE 8000
+
+# Command to run the FastAPI app using Uvicorn
+CMD ["uvicorn", "App.app:app", "--host", "0.0.0.0", "--port", "8000"]

call.py

@@ -0,0 +1,5 @@
+import uvicorn
+
+if __name__ == "__main__":
+    # Run the FastAPI app located at App.app:app
+    uvicorn.run("App.app:app", host="0.0.0.0", port=8000, reload=True)

requirements.txt

@@ -2,7 +2,9 @@ fastapi
 passlib
 pydantic[email]
 uvicorn
-jose
+python-jose
+bcrypt
 httpx
 pytest
+asyncpg
 tortoise-orm

vercel.json

@@ -0,0 +1,14 @@
+{
+  "builds": [
+    {
+      "src": "App/app.py",
+      "use": "@vercel/python"
+    }
+  ],
+  "routes": [
+    {
+      "src": "/(.*)",
+      "dest": "App/app.py"
+    }
+  ]
+}