testing playment not done

App/Messages/MessagesRoute.py

@@ -1,12 +1,18 @@
 # App/Messages/Routes.py
 from fastapi import APIRouter, HTTPException, Request
 from .Model import Message
-from .Schema import MessageCreate, MessageResponse
+from .Schema import MessageCreate, MessageResponse, TransactionSchema
 from uuid import UUID
 from typing import List, Optional
 import re
 from datetime import datetime
 from decimal import Decimal
+from App.Payments.PaymentsRoutes import create_payment
+from App.Payments.Schema import CreatePaymentRequest
+from App.Users.Model import User
+from App.Payments.Schema import PaymentMethod
+from App.Payments.Model import Payment
+from App.Plans.Model import Plan
 
 message_router = APIRouter(tags=["Messages"], prefix="/messages")
 
@@ -15,7 +21,6 @@ message_router = APIRouter(tags=["Messages"], prefix="/messages")
 async def receive_message(request: Request):
 
     message_raw = await request.json()
-    print(message_raw)
     message_data = MessageCreate(**message_raw)
     try:
         # Extract data from the message content using regex
@@ -34,19 +39,37 @@ async def receive_message(request: Request):
             sim_number=message_data.payload.simNumber,
             parsed_data=parsed_data,
         )
-        return MessageResponse.from_orm(new_message)
+
+        # Process Mpesa Payments
+        if parsed_data:
+            user: User = User.get_or_none(phoneNumber=parsed_data.phone_number)
+            data_plan: Plan = Plan.get_or_none(
+                amount=Decimal(parsed_data.amount_received)
+            )
+            payment_details = CreatePaymentRequest(
+                user_id=user.id,
+                plan_id=data_plan.id,
+                amount=Decimal(parsed_data.amount_received),
+                payment_method=PaymentMethod.MPESA,
+                transaction_id=parsed_data.transaction_id,
+            )
+        data = MessageResponse.from_orm(new_message)
+
+        payment: Payment = await create_payment(payment_details)
+        await payment.create_subscription_or_balance()
+        return data
     except Exception as e:
         raise HTTPException(status_code=400, detail=str(e))
 
 
-def parse_message_content(text: str) -> Optional[dict]:
+def parse_message_content(text: str) -> Optional[TransactionSchema]:
     # Regular expression to capture the data from the message, allowing for different types of spaces
     pattern = r"(\w+)\sConfirmed\.You have received Tsh([\d,]+\.\d{2}) from (\d{12}) - ([A-Z ]+) on (\d{1,2}/\d{1,2}/\d{2}) at ([\d:]+ [APM]+).*?balance\sis\sTsh([\d,]+\.\d{2})"
 
     # Replace non-breaking spaces and other whitespace characters with regular spaces in the input text
     text = re.sub(r"\s+", " ", text)
 
-    matches = re.search(pattern, text)
+    matches: TransactionSchema = re.search(pattern, text)
     if matches:
         data = {
             "transaction_id": matches.group(1),

App/Messages/Schema.py

@@ -1,9 +1,18 @@
 # App/Messages/Schema.py
-from pydantic import BaseModel, UUID4, Field, ConfigDict
+from pydantic import BaseModel, UUID4, Field, ConfigDict, condecimal, constr
 from datetime import datetime
 from typing import Optional
 
 
+class TransactionSchema(BaseModel):
+    transaction_id: str
+    amount_received: float
+    phone_number: str
+    name: str
+    date: datetime
+    new_balance: float
+
+
 class PayloadSchema(BaseModel):
     message: str
     phoneNumber: str

App/Payments/Model.py

@@ -66,3 +66,35 @@ class Payment(Model):
             else:
                 self.status = "insufficient-funds"
             await self.save()
+
+    async def create_subscription_or_balance(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.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()
+
+        if not self.plan and self.user:
+            self.user.balance += self.amount
+            await self.user.save()
+            self.status = "subscription-created"
+            await self.save()