messages

App/Messages/MessagesRoute.py

@@ -0,0 +1,75 @@
+# App/Messages/Routes.py
+from fastapi import APIRouter, HTTPException, Request
+from .Model import Message
+from .Schema import MessageCreate, MessageResponse
+from uuid import UUID
+from typing import List, Optional
+import re
+from datetime import datetime
+from decimal import Decimal
+
+message_router = APIRouter(tags=["Messages"], prefix="/messages")
+
+
+@message_router.post("/sms_received", response_model=MessageResponse)
+async def receive_message(request: Request):
+
+    message_raw = await request.json()
+    message_data = MessageCreate(**message_raw)
+    try:
+        # Extract data from the message content using regex
+        text = message_data.payload.message
+        parsed_data = parse_message_content(text)
+
+        # Create a new message record with parsed_data
+        new_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,
+            phone_number=message_data.payload.phoneNumber,
+            received_at=message_data.payload.receivedAt,
+            sim_number=message_data.payload.simNumber,
+            parsed_data=parsed_data,
+        )
+        return MessageResponse.from_orm(new_message)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+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 is Tsh([\d,]+\.\d{2})"
+
+    matches = re.search(pattern, text)
+    if matches:
+        data = {
+            "transaction_id": matches.group(1),
+            "amount_received": parse_decimal(matches.group(2)),
+            "phone_number": matches.group(3),
+            "name": matches.group(4).strip(),
+            "date": parse_date(matches.group(5), matches.group(6)),
+            "new_balance": parse_decimal(matches.group(7)),
+        }
+        return data
+    else:
+        # Return None if the message doesn't match the expected format
+        return None
+
+
+def parse_decimal(amount_str: str) -> float:
+    # Remove commas and convert to Decimal
+    amount_str = amount_str.replace(",", "")
+    return float(Decimal(amount_str))
+
+
+def parse_date(date_str: str, time_str: str) -> str:
+    # Combine date and time strings and parse into ISO format
+    datetime_str = f"{date_str} {time_str}"
+    # Adjust the format as per the actual format in the message
+    try:
+        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

App/Messages/Model.py

@@ -0,0 +1,27 @@
+# App/Messages/Model.py
+from tortoise import fields, models
+from uuid import uuid4
+from datetime import datetime
+from tortoise.models import Model
+
+
+class Message(Model):
+    id = fields.UUIDField(pk=True, default=uuid4)
+    device_id = fields.CharField(max_length=100, null=True)
+    event = fields.CharField(max_length=100, null=True)
+    message_id = fields.CharField(
+        max_length=100, null=True
+    )  # Corresponds to 'id' in the JSON
+    webhook_id = fields.CharField(max_length=100, null=True)
+    message_content = fields.TextField()
+    phone_number = fields.CharField(max_length=20)
+    received_at = fields.DatetimeField()
+    sim_number = fields.IntField(null=True)
+    parsed_data = fields.JSONField(null=True)  # New field for parsed data
+    created_time = fields.DatetimeField(auto_now_add=True)
+
+    class Meta:
+        table = "messages"
+
+    def __str__(self):
+        return f"Message from {self.phone_number} at {self.received_at}"

App/Messages/Schema.py

@@ -0,0 +1,38 @@
+# App/Messages/Schema.py
+from pydantic import BaseModel, UUID4, Field, ConfigDict
+from datetime import datetime
+from typing import Optional
+
+
+class PayloadSchema(BaseModel):
+    message: str
+    phoneNumber: str
+    receivedAt: datetime
+    simNumber: Optional[int]
+
+
+class MessageCreate(BaseModel):
+    deviceId: Optional[str]
+    event: Optional[str]
+    id: Optional[str] = Field(alias="messageId")  # Renaming to prevent conflict
+    payload: PayloadSchema
+    webhookId: Optional[str]
+
+
+class MessageResponse(BaseModel):
+    id: UUID4
+    device_id: Optional[str]
+    event: Optional[str]
+    message_id: Optional[str]
+    webhook_id: Optional[str]
+    message_content: str
+    phone_number: str
+    received_at: datetime
+    sim_number: Optional[int]
+    parsed_data: Optional[dict]  # Include parsed_data in the response
+    created_time: datetime
+    model_config = ConfigDict(from_attributes=True)
+
+    # class Config:
+    #     orm_mode = True
+    #     allow_population_by_field_name = True

App/app.py

@@ -8,6 +8,7 @@ from .Payments.PaymentsRoutes import payment_router
 from .Plans.PlanRoutes import plan_router
 from .Portals.PortalRoutes import portal_router
 from .Metrics.MetricsRoutes import metrics_router
+from .Messages.MessagesRoute import message_router
 
 app = FastAPI()
 
@@ -30,6 +31,7 @@ app.include_router(payment_router)
 app.include_router(plan_router)
 app.include_router(portal_router)
 app.include_router(metrics_router)
+app.include_router(message_router)
 
 
 if __name__ == "__main__":

App/discovery.py

@@ -28,7 +28,7 @@ def discover_models(target_file: str, directory: str = None) -> List[str]:
                 os.sep, "."
             )  # Correct dot notation
             module_name = module_name[:-3]  # Remove '.py' extension
-            model_modules.append(module_name)
+            model_modules.append("App." + module_name)
 
     print("Discovered models:", model_modules)
     return model_modules

App/modelInit.py

@@ -26,13 +26,7 @@ TORTOISE_ORM = {
     },
     "apps": {
         "models": {
-            "models": [
-                "App.Payments.Model",
-                "App.Plans.Model",
-                "App.Portals.Model",
-                "App.Subscriptions.Model",
-                "App.Users.Model",
-            ],
+            "models": models,
             "default_connection": "default",
         }
     },