Working registration, testing payments

App/Android/Android.py

@@ -1,5 +1,6 @@
 import httpx
-from typing import Optional
+from typing import Optional, Union, List
+from functools import wraps
 from .Schema import (
     RegisterUserRequest,
     LoginRequest,
@@ -10,48 +11,90 @@ from App.Portals.PortalRoutes import ANDROID
 from App.Portals.Model import Portal
 
 
+def require_base_url(func):
+    """Decorator to set base_url before making a request."""
+
+    @wraps(func)
+    async def wrapper(self, *args, **kwargs):
+        await self.set_base_url()
+        return await func(self, *args, **kwargs)
+
+    return wrapper
+
+
 class AndroidClient:
     def __init__(self):
-        self.base_url = "http://127.0.0.1:8080/"
-        self.client = httpx.AsyncClient(base_url=self.base_url)
+        self.client = httpx.AsyncClient()
+
+    async def set_base_url(self):
+        """Fetch the base_url from the database."""
+        portal = await Portal.get(name=ANDROID)
+        self.client.base_url = portal.url
 
+    @require_base_url
     async def register_user(self, request: RegisterUserRequest) -> APIResponse:
         """Register a new user."""
         response = await self.client.post("/users/register", json=request.dict())
         return APIResponse(**response.json())
 
+    @require_base_url
     async def login_user(self, request: LoginRequest) -> APIResponse:
         """Login an existing user."""
         response = await self.client.post("/login", json=request.dict())
         return APIResponse(**response.json())
 
+    @require_base_url
     async def logout_user(self, phone: str) -> APIResponse:
         """Logout a user by phone."""
         response = await self.client.post(f"/logout/{phone}")
         return APIResponse(**response.json())
 
+    @require_base_url
     async def get_active_users(self) -> APIResponse:
         """Retrieve all active users."""
         response = await self.client.get("/users/active")
         print(response.json())
         return APIResponse(**response.json())
 
+    @require_base_url
     async def set_user_status(self, request: SetUserStatusRequest) -> APIResponse:
         """Enable or disable a user."""
         response = await self.client.patch("/user/status", json=request.dict())
         return APIResponse(**response.json())
 
+    @require_base_url
     async def get_users_list(self) -> APIResponse:
         """Retrieve all users (active and inactive)."""
         response = await self.client.get("/users")
         return APIResponse(**response.json())
 
+    @require_base_url
     async def get_user_stats(self, phone: Optional[str] = None) -> APIResponse:
         """Retrieve user statistics for a specific user or all users."""
         url = f"/user/stats/{phone}" if phone else "/user/stats"
         response = await self.client.get(url)
         return APIResponse(**response.json())
 
+    @require_base_url
+    async def send_message(
+        self,
+        message: str,
+        phone_numbers: Union[str, List[str]],
+        event: str = "string",
+    ) -> APIResponse:
+        """Send a message to a single phone number or a list of phone numbers."""
+        # Ensure phone_numbers is a list
+        if isinstance(phone_numbers, str):
+            phone_numbers = [phone_numbers]
+        data = {
+            "message": message,
+            "phoneNumbers": phone_numbers,
+            "event": event,
+        }
+        response = await self.client.post("/send_message", json=data)
+        print(response)
+        return response
+
     async def close(self):
         """Close the client session."""
         await self.client.aclose()

App/Android/Schema.py

@@ -6,9 +6,9 @@ from typing import Optional, Dict, Any, List
 
 
 class RegisterUserRequest(BaseModel):
-    phone: str
+    phoneNumber: str
     password: str
-    profile: Optional[str] = "default"
+    profile: Optional[str] = "2mbps_profile"
 
 
 class LoginRequest(BaseModel):

App/Messages/MessagesRoute.py

@@ -48,14 +48,11 @@ async def receive_message(message_data: MessageCreate):
             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,
+                user_id=user.id if user else None,
                 plan_id=str(data_plan.id) if data_plan else None,
                 amount=Decimal(parsed_data["amount_received"]),
                 payment_method=PaymentMethod.MPESA,

App/Payments/Model.py

@@ -1,3 +1,5 @@
+# App/Payments/Model.py
+
 from tortoise import fields
 from tortoise.models import Model
 import datetime
@@ -6,6 +8,17 @@ from App.Users.Model import User
 from App.Plans.Model import Plan
 from App.Subscriptions.Model import Subscription
 from .Schema import PaymentMethod
+from App.Android.Android import AndroidClient
+from App.Templates.Templates import MessageTemplate
+import logging
+
+# Configure logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
 
 
 class Payment(Model):
@@ -37,6 +50,10 @@ class Payment(Model):
     created_time = fields.DatetimeField(auto_now_add=True)
     updated_time = fields.DatetimeField(auto_now=True)
 
+    # Initialize AndroidClient and MessageTemplate as class variables
+    android_client = AndroidClient()
+    message_templates = MessageTemplate()
+
     class Meta:
         table = "payments"
 
@@ -57,9 +74,18 @@ class Payment(Model):
                     active=True,
                 )
                 self.status = "subscription-created"
+                await self.save()
+                # Send payment success message with subscription details
+                await self.user.send_payment_success_message(
+                    amount=self.amount, plan_name=self.plan.name
+                )
             else:
                 self.status = "insufficient-funds"
-            await self.save()
+                await self.save()
+                # Send insufficient funds message
+                await self.user.send_insufficient_funds_message(
+                    required_amount=self.plan.amount, attempted_amount=self.amount
+                )
 
     async def create_subscription_or_balance(self):
         if self.user and self.plan:
@@ -68,6 +94,7 @@ class Payment(Model):
                     hours=self.plan.duration
                 )
                 user = await self.user
+
                 # Create the subscription
                 await Subscription.create(
                     user=user,
@@ -79,10 +106,18 @@ class Payment(Model):
                     active=True,
                 )
                 self.status = "subscription-created"
+                await self.save()
+                # Send payment success message with subscription details
+                await user.send_payment_success_message(
+                    amount=self.amount, plan_name=self.plan.name
+                )
             else:
                 self.status = "insufficient-funds"
-            await self.save()
-
+                await self.save()
+                # Send insufficient funds message
+                await user.send_insufficient_funds_message(
+                    required_amount=self.plan.amount, attempted_amount=self.amount
+                )
         elif not self.plan and self.user:
             # Await the related user object
             user = await self.user
@@ -90,3 +125,5 @@ class Payment(Model):
             await user.save()
             self.status = "balance-assigned"
             await self.save()
+            # Send payment success message with balance assignment
+            await user.send_payment_success_message(amount=self.amount)

App/Templates/Payment.md

@@ -0,0 +1,3 @@
+Asante kwa malipo yako ya {{ amount }} TSH kwa huduma ya {{ business_name }}.  
+Muunganisho wako upo tayari na utadumu hadi {{ expiry_date }}.  
+Furahia mtandao wetu!

App/Templates/Registration.md

@@ -0,0 +1,3 @@
+Karibu {{ user_name }}! Akaunti yako imefanikiwa kusajiliwa.
+Mambo ni buku buku tu!!!
+Asante kwa kuchagua {{ business_name }}!

App/Templates/Templates.py

@@ -0,0 +1,57 @@
+import os
+from jinja2 import Environment, FileSystemLoader
+from decimal import Decimal
+
+BUSINESS = "Goba Buku Wifi😉"
+
+
+class MessageTemplate:
+    def __init__(self):
+        # Set the template directory to the same directory as this file
+        template_dir = os.path.dirname(__file__)
+        self.env = Environment(loader=FileSystemLoader(template_dir))
+
+    def render_template(self, template_name: str, **kwargs) -> str:
+        """Renders a template with provided variables."""
+        template = self.env.get_template(template_name)
+        return template.render(**kwargs)
+
+    def registration_message(self, user_name, business_name=BUSINESS):
+        """Generates the registration message for SMS."""
+        return self.render_template(
+            "registration.md",
+            user_name=user_name,
+            business_name=business_name,
+        )
+
+    def payment_confirmation_message(self, amount, expiry_date, business_name=BUSINESS):
+        """Generates the payment confirmation message for SMS."""
+        return self.render_template(
+            "payment_confirmation.md",
+            amount=amount,
+            expiry_date=expiry_date,
+            business_name=business_name,
+        )
+
+    def account_disabled_message(self) -> str:
+        return "Akaunti yako imezimwa. Tafadhali wasiliana na msaada kwa usaidizi."
+
+    def account_enabled_message(self) -> str:
+        return "Akaunti yako imewashwa. Sasa unaweza kufikia akaunti yako."
+
+    def reset_token_message(self, token: str) -> str:
+        return f"Tokeni yako ya kuweka upya nenosiri ni: {token}. Tafadhali tumia tokeni hii kuweka upya nenosiri lako."
+
+    def password_reset_confirmation_message(self) -> str:
+        return "Nenosiri lako limewekwa upya kwa mafanikio. Ikiwa hukufanya kitendo hiki, tafadhali wasiliana na msaada mara moja."
+
+    def subscription_created_message(self, plan_name: str, expiration_time: str) -> str:
+        return f"Habari! Usajili wako kwenye mpango wa {plan_name} umefanikiwa kuundwa. Utaisha tarehe {expiration_time}."
+
+    def insufficient_funds_message(
+        self, required_amount: Decimal, provided_amount: Decimal
+    ) -> str:
+        return f"Pesa hazitoshi kwa mpango uliyochagua. Zinazohitajika: {required_amount}, Zilizotolewa: {provided_amount}. Tafadhali ongeza pesa zaidi au chagua mpango tofauti."
+
+    def balance_assigned_message(self, amount: Decimal, new_balance: Decimal) -> str:
+        return f"Habari! Salio la {amount} limeongezwa kwa mafanikio kwenye akaunti yako. Salio lako jipya ni {new_balance}."

App/Users/Model.py

@@ -1,21 +1,39 @@
+# .Model.py
+
 from tortoise import fields, models
 from passlib.context import CryptContext
+from App.Android.Android import AndroidClient
+from App.Android.Schema import RegisterUserRequest as AndroidRegister
+from App.Templates.Templates import MessageTemplate
 import datetime
 import uuid
 import random
 import string
+from typing import Optional
+from decimal import Decimal
+import logging
+
+# Configure logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
 
+# Password hashing context
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 
 def generate_short_uuid() -> str:
+    """Generates a random 5-character alphanumeric ID."""
     return "".join(random.choices(string.ascii_letters + string.digits, k=5))
 
 
 class User(models.Model):
     id = fields.CharField(primary_key=True, max_length=5, default=generate_short_uuid)
     name = fields.CharField(max_length=100)
-    password = fields.CharField(max_length=100)
+    password = fields.CharField(max_length=100)  # Stores hashed password
     phoneNumber = fields.CharField(max_length=15, unique=True)
     balance = fields.DecimalField(max_digits=10, decimal_places=2, default=0.00)
     mac_address = fields.CharField(max_length=17)
@@ -30,16 +48,27 @@ class User(models.Model):
     class Meta:
         table = "users"
 
+    # Initialize AndroidClient and MessageTemplate as class variables
+    android_client = AndroidClient()
+    message_templates = MessageTemplate()
+
     def hash_password(self, plain_password: str) -> str:
+        """Hashes a plain password."""
         return pwd_context.hash(plain_password)
 
     def verify_password(self, plain_password: str) -> bool:
+        """
+        Verifies a plain password against the hashed password.
+        Handles account locking after multiple 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.")
+            logger.warning(
+                f"Account {self.phoneNumber} is locked due to too many failed attempts."
+            )
             return False
 
         if pwd_context.verify(plain_password, self.password):
@@ -52,24 +81,180 @@ class User(models.Model):
             self.failed_attempts += 1
             if self.failed_attempts >= 5:
                 self.account_locked = True
+                logger.warning(f"Account {self.phoneNumber} has been locked.")
             self.save()
             return False
 
     async def initiate_password_reset(self):
+        """Generates a reset token and sends it to the user via message."""
         self.reset_token = f"{random.randint(100000, 999999)}"
         self.reset_token_expiration = datetime.datetime.now() + datetime.timedelta(
             minutes=15
         )
         await self.save()
+        await self.send_reset_token_message()
 
-    async def reset_password(self, reset_token: str, new_password: str):
+    async def reset_password(self, reset_token: str, new_password: str) -> bool:
+        """
+        Resets the user's password if the provided token is valid and not expired.
+        Sends a confirmation message upon successful reset.
+        """
         if (
             self.reset_token != reset_token
             or datetime.datetime.now() > self.reset_token_expiration
         ):
+            logger.error(f"Invalid or expired reset token for user {self.phoneNumber}.")
             return False
         self.password = self.hash_password(new_password)
         self.reset_token = None
         self.reset_token_expiration = None
         await self.save()
+        await self.send_password_reset_confirmation()
         return True
+
+    @classmethod
+    async def create_user(cls, user_data: dict) -> models.Model:
+        """
+        Creates a new user, registers with AndroidClient, and sends a welcome message.
+        """
+        try:
+            # Hash the plain password
+            plain_password = user_data.get("password")
+            if not plain_password:
+                logger.error("Password not provided during user creation.")
+                raise ValueError("Password is required.")
+            hashed_password = pwd_context.hash(plain_password)
+            user_data["password"] = hashed_password
+
+            # Create the user in the database
+            new_user = await cls.create(**user_data)
+            logger.info(f"User {new_user.phoneNumber} created successfully.")
+
+            # Register with AndroidClient
+            register_request = AndroidRegister(
+                password=plain_password,  # Assuming AndroidClient expects plain password
+                phoneNumber=new_user.phoneNumber,
+            )
+            try:
+                response = await cls.android_client.register_user(
+                    request=register_request
+                )
+                logger.info(
+                    f"AndroidClient register_user response for {new_user.phoneNumber}: {response}"
+                )
+            except Exception as e:
+                logger.error(
+                    f"Failed to register user with AndroidClient for {new_user.phoneNumber}: {e}"
+                )
+                # Decide whether to rollback user creation or proceed
+                # For simplicity, we'll proceed
+
+            # Send welcome message
+            await new_user.send_welcome_message()
+
+            return new_user
+        except Exception as e:
+            logger.error(f"Error creating user: {e}")
+            raise e
+
+    async def send_welcome_message(self):
+        """Sends a welcome message to the user."""
+        message = self.message_templates.registration_message(user_name=self.name)
+        try:
+            await self.android_client.send_message(
+                phone_numbers=self.phoneNumber, message=message
+            )
+            logger.info(f"Welcome message sent to {self.phoneNumber}.")
+        except Exception as e:
+            logger.error(f"Failed to send welcome message to {self.phoneNumber}: {e}")
+
+    async def send_reset_token_message(self):
+        """Sends the reset token to the user's phone number."""
+        message = self.message_templates.reset_token_message(token=self.reset_token)
+        try:
+            await self.android_client.send_message(
+                phone_numbers=self.phoneNumber, message=message
+            )
+            logger.info(f"Reset token sent to {self.phoneNumber}.")
+        except Exception as e:
+            logger.error(f"Failed to send reset token to {self.phoneNumber}: {e}")
+
+    async def send_password_reset_confirmation(self):
+        """Sends a confirmation message after a successful password reset."""
+        message = self.message_templates.password_reset_confirmation_message()
+        try:
+            await self.android_client.send_message(
+                phone_numbers=self.phoneNumber, message=message
+            )
+            logger.info(f"Password reset confirmation sent to {self.phoneNumber}.")
+        except Exception as e:
+            logger.error(
+                f"Failed to send password reset confirmation to {self.phoneNumber}: {e}"
+            )
+
+    async def toggle_account_status(self):
+        """Toggles the user's account status and sends a notification message."""
+        self.account_locked = not self.account_locked
+        await self.save()
+        if self.account_locked:
+            message = self.message_templates.account_disabled_message()
+            logger.info(f"Account {self.phoneNumber} has been locked.")
+        else:
+            message = self.message_templates.account_enabled_message()
+            logger.info(f"Account {self.phoneNumber} has been unlocked.")
+
+        try:
+            await self.android_client.send_message(
+                phone_numbers=self.phoneNumber, message=message
+            )
+            logger.info(f"Account status message sent to {self.phoneNumber}.")
+        except Exception as e:
+            logger.error(
+                f"Failed to send account status message to {self.phoneNumber}: {e}"
+            )
+
+    async def send_payment_success_message(
+        self, amount: Decimal, plan_name: Optional[str] = None
+    ):
+        """
+        Sends a payment success message to the user.
+        If a plan is associated, it includes subscription details.
+        """
+        if plan_name:
+            message = self.message_templates.payment_success_subscription_message(
+                user_name=self.name, amount=amount, plan_name=plan_name
+            )
+        else:
+            message = self.message_templates.payment_success_balance_message(
+                user_name=self.name, amount=amount
+            )
+        try:
+            await self.android_client.send_message(
+                phone_numbers=self.phoneNumber, message=message
+            )
+            logger.info(f"Payment success message sent to {self.phoneNumber}.")
+        except Exception as e:
+            logger.error(
+                f"Failed to send payment success message to {self.phoneNumber}: {e}"
+            )
+
+    async def send_insufficient_funds_message(
+        self, required_amount: Decimal, attempted_amount: Decimal
+    ):
+        """
+        Sends a message to the user indicating insufficient funds for the attempted payment.
+        """
+        message = self.message_templates.insufficient_funds_message(
+            user_name=self.name,
+            required_amount=required_amount,
+            attempted_amount=attempted_amount,
+        )
+        try:
+            await self.android_client.send_message(
+                phone_numbers=self.phoneNumber, message=message
+            )
+            logger.info(f"Insufficient funds message sent to {self.phoneNumber}.")
+        except Exception as e:
+            logger.error(
+                f"Failed to send insufficient funds message to {self.phoneNumber}: {e}"
+            )

App/Users/UserRoutes.py

@@ -14,12 +14,16 @@ from jose import jwt
 from typing import List
 from datetime import datetime, timedelta
 from App.Android.Android import AndroidClient
+from App.Android.Schema import RegisterUserRequest as AndroidRegister
+from App.Templates.Templates import MessageTemplate
 
 # JWT Configurations
 SECRET_KEY = "your_secret_key_here"
 ALGORITHM = "HS256"
 ACCESS_TOKEN_EXPIRE_MINUTES = 30
 user_router = APIRouter(tags=["User"])
+client = AndroidClient()
+templates = MessageTemplate()
 
 
 def create_access_token(data: dict, expires_delta: timedelta = None):
@@ -31,6 +35,11 @@ def create_access_token(data: dict, expires_delta: timedelta = None):
     return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
 
 
+# The user registers
+# It sends userdetails to the router
+# It sends the user a message to welcome the user
+
+
 @user_router.post(
     "/user/register", response_model=BaseResponse, status_code=status.HTTP_201_CREATED
 )
@@ -40,13 +49,8 @@ async def register_user(request: RegisterUserRequest):
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST, detail="User already exists."
         )
-    # client part
-    client = AndroidClient()
-    print(request.json())
-    response = await client.register_user(request=request)
-    print(response)
-    request.hash_password()
-    new_user = await User.create(**request.dict())
+
+    new_user = await User.create_user(request.dict())
     return BaseResponse(
         code=200, message="User created successfully", payload={"user_id": new_user.id}
     )

requirements.txt

@@ -7,4 +7,6 @@ bcrypt
 httpx
 pytest
 asyncpg
-tortoise-orm
+tortoise-orm
+markdown2
+jinja2