nice

App/Messages/MessagesRoute.py

@@ -1,9 +1,8 @@
 # App/Messages/Routes.py
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException
 from .Model import Message
-from .Schema import MessageCreate, MessageResponse, TransactionSchema
-from uuid import UUID
-from typing import List, Optional
+from .Schema import MessageCreate, MessageResponse
+from typing import Optional
 import re
 from datetime import datetime
 from decimal import Decimal
@@ -14,71 +13,94 @@ from App.Payments.Schema import PaymentMethod
 from App.Payments.Model import Payment
 from App.Plans.Model import Plan
 from tortoise.contrib.pydantic import pydantic_model_creator
+import traceback
+import logging
 
 message_router = APIRouter(tags=["Messages"], prefix="/messages")
+logging.basicConfig(level=logging.WARNING)
 
 
 @message_router.post("/sms_received", response_model=MessageResponse)
 async def receive_message(message_data: MessageCreate):
-    message = Message.get_or_none(message_id=message_data.id)
     Message_Pydantic = pydantic_model_creator(Message)
     try:
         # Extract data from the message content using regex
         text = message_data.payload.message
         parsed_data = parse_message_content(text)
 
-        # Process Mpesa Payments and prevent double entry from the sms gateway app (message_id must be unique)
-        if parsed_data and not message:
-            user: User = User.get_or_none(phoneNumber=parsed_data.phone_number)
+        # Validate parsed_data
+        if not parsed_data:
+            raise HTTPException(
+                status_code=400, detail="Failed to parse message content."
+            )
 
-            # if the user sent an exact amount
-            data_plan: Plan = Plan.get_or_none(
-                amount=Decimal(parsed_data.amount_received)
+        required_keys = ["phone_number", "amount_received", "transaction_id"]
+        missing_keys = [key for key in required_keys if key not in parsed_data]
+        if missing_keys:
+            raise HTTPException(
+                status_code=400, detail=f"Missing keys in parsed data: {missing_keys}"
+            )
+
+        # Prevent double entry from the SMS gateway app
+        message = await Message.get_or_none(message_id=message_data.id)
+        if not message:
+            # Process Mpesa Payments
+            user: User = await User.get_or_none(
+                phoneNumber="+" + parsed_data["phone_number"]
+            )
+            if not user:
+                raise HTTPException(status_code=404, detail="User not found.")
+
+            data_plan: Plan = await 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),
+                plan_id=str(data_plan.id) if data_plan else None,
+                amount=Decimal(parsed_data["amount_received"]),
                 payment_method=PaymentMethod.MPESA,
-                transaction_id=parsed_data.transaction_id,
+                transaction_id=parsed_data["transaction_id"],
             )
 
-            payment: Payment = await create_payment(payment_details)
+            # Ensure 'create_payment' is an async function
+            payment: Payment = await create_payment(payment_details, internal=True)
             await payment.create_subscription_or_balance()
 
-        # prevent double entries
-        if not message:
             # Create a new message record with parsed_data
             message = await Message.create(
                 device_id=message_data.deviceId,
                 event=message_data.event,
                 message_id=message_data.id,
                 webhook_id=message_data.webhookId,
-                message_content=text,
+                message_content=message_data.payload.message,
                 phone_number=message_data.payload.phoneNumber,
                 received_at=message_data.payload.receivedAt,
                 sim_number=message_data.payload.simNumber,
                 parsed_data=parsed_data,
             )
-        print(message.__dict__)
-        if type(message) == Message:
-            data = await Message_Pydantic.from_tortoise_orm(message)
-        else:
-            data = await Message_Pydantic.from_queryset_single(message)
 
+        # Serialize the message
+        data = await Message_Pydantic.from_tortoise_orm(message)
         return data
+
     except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
+        # Log the full traceback
+        traceback_str = "".join(traceback.format_exception(None, e, e.__traceback__))
+        logging.error(f"An error occurred: {traceback_str}")
+
+        # Provide a default error message if 'e' is empty
+        error_message = str(e) if str(e) else "An unexpected error occurred."
+        raise HTTPException(status_code=500, detail=error_message)
 
 
-def parse_message_content(text: str) -> Optional[TransactionSchema]:
-    # Regular expression to capture the data from the message, allowing for different types of spaces
+def parse_message_content(text: str) -> Optional[dict]:
+    # Regular expression to capture the data from the message
     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
+    # Replace non-breaking spaces and other whitespace characters with regular spaces
     text = re.sub(r"\s+", " ", text)
 
-    matches: TransactionSchema = re.search(pattern, text)
+    matches = re.search(pattern, text)
     if matches:
         data = {
             "transaction_id": matches.group(1),
@@ -95,7 +117,7 @@ def parse_message_content(text: str) -> Optional[TransactionSchema]:
 
 
 def parse_decimal(amount_str: str) -> float:
-    # Remove commas and convert to Decimal
+    # Remove commas and convert to float
     amount_str = amount_str.replace(",", "")
     return float(Decimal(amount_str))
 
@@ -107,4 +129,7 @@ def parse_date(date_str: str, time_str: str) -> str:
         dt = datetime.strptime(datetime_str, "%d/%m/%y %I:%M %p")
         return dt.isoformat()
     except ValueError:
-        return datetime_str  # Return as-is if parsing fails
+        # Log the error
+        logging.error(f"Failed to parse date: {datetime_str}")
+        # Return current time as fallback
+        return datetime.now().isoformat()

App/Payments/Model.py

@@ -41,23 +41,17 @@ class Payment(Model):
         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
+                    download_mb=self.plan.download_speed * 1024,
+                    upload_mb=self.plan.upload_speed * 1024,
                     created_time=datetime.datetime.now(),
                     expiration_time=expiration_time,
                     active=True,
@@ -68,22 +62,18 @@ class Payment(Model):
             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
                 )
+                user = await self.user
                 # Create the subscription
                 await Subscription.create(
-                    user=self.user,
+                    user=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
+                    download_mb=self.plan.download_speed * 1024,
+                    upload_mb=self.plan.upload_speed * 1024,
                     created_time=datetime.datetime.now(),
                     expiration_time=expiration_time,
                     active=True,
@@ -93,8 +83,10 @@ class Payment(Model):
                 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"
+        elif not self.plan and self.user:
+            # Await the related user object
+            user = await self.user
+            user.balance += self.amount
+            await user.save()
+            self.status = "balance-assigned"
             await self.save()

App/Payments/PaymentsRoutes.py

@@ -17,7 +17,7 @@ payment_router = APIRouter(tags=["Payments"])
 
 
 @payment_router.post("/payment/create", response_model=BaseResponse)
-async def create_payment(request: CreatePaymentRequest):
+async def create_payment(request: CreatePaymentRequest, internal=False):
     # If payment method is "Lipa Number", transaction_id is required
     if (
         request.payment_method == PaymentMethod.LIPA_NUMBER
@@ -45,6 +45,9 @@ async def create_payment(request: CreatePaymentRequest):
         status="pending",  # Default status
     )
 
+    if internal:
+        return payment
+
     # If payment method is "cash", attempt to create a subscription
     if payment.payment_method == PaymentMethod.CASH:
         await payment.create_subscription_if_cash()