user powers not tested

App/Payments/Model.py

@@ -60,19 +60,23 @@ class Payment(Model):
     async def create_subscription_if_cash(self):
         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,
-                    upload_mb=self.plan.upload_speed * 1024,
-                    created_time=datetime.datetime.now(),
-                    expiration_time=expiration_time,
-                    active=True,
-                )
+                await self.fetch_related("user", "plan")
+                # 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,
+                #     upload_mb=self.plan.upload_speed * 1024,
+                #     created_time=datetime.datetime.now(),
+                #     expiration_time=expiration_time,
+                #     active=True,
+                # )
+
+                self.user: User
+                await self.user.create_subscription(self.plan)
                 self.status = "subscription-created"
                 await self.save()
                 # Send payment success message with subscription details
@@ -90,27 +94,31 @@ class Payment(Model):
     async def create_subscription_or_balance(self):
         if self.user and self.plan:
             if self.amount >= self.plan.amount:
-                expiration_time = datetime.datetime.now() + datetime.timedelta(
-                    hours=self.plan.duration
-                )
+                await self.fetch_related("user", "plan")
+                # 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,
+                #     upload_mb=self.plan.upload_speed * 1024,
+                #     created_time=datetime.datetime.now(),
+                #     expiration_time=expiration_time,
+                #     active=True,
+                # )
                 user = await self.user
 
-                # Create the subscription
-                await Subscription.create(
-                    user=user,
-                    duration=self.plan.duration,
-                    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,
-                )
+                self.user: User
+                await self.user.create_subscription(self.plan)
                 self.status = "subscription-created"
                 await self.save()
                 # Send payment success message with subscription details
-                await user.send_payment_success_message(
+                await self.user.send_payment_success_message(
                     amount=self.amount, plan_name=self.plan.name
                 )
+
             else:
                 self.status = "insufficient-funds"
                 await self.save()

App/Plans/Model.py

@@ -1,5 +1,6 @@
 from tortoise import fields
 from tortoise.models import Model
+from datetime import datetime, timedelta
 
 
 class Plan(Model):
@@ -13,6 +14,36 @@ class Plan(Model):
     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")
+    expire_date = fields.DatetimeField(
+        default=None, null=True, description="Expiration date of the plan"
+    )
+    is_promo = fields.BooleanField(
+        default=False, description="Indicates if the plan is a promotional plan"
+    )
+    promo_duration_days = fields.IntField(
+        default=None, null=True, description="Number of days the promotion is valid"
+    )
+    is_valid = fields.BooleanField(
+        default=True, description="Indicates if the plan is valid"
+    )
 
     class Meta:
         table = "plans"
+
+    async def set_expiration(self):
+        """Set the expiration date based on the promo duration if applicable."""
+        if self.is_promo and self.promo_duration_days:
+            self.expire_date = datetime.now() + timedelta(days=self.promo_duration_days)
+        elif self.duration:
+            self.expire_date = datetime.now() + timedelta(
+                days=self.duration // 24
+            )  # Convert hours to days
+        await self.save()
+
+    async def is_promo_valid(self) -> bool:
+        """Check if the promotional plan is still valid."""
+        if self.is_promo and self.expire_date:
+            return datetime.now() < self.expire_date
+        self.is_valid = False
+        await self.save()
+        return False

App/Plans/PlanRoutes.py

@@ -22,7 +22,25 @@ async def create_plan(request: CreatePlanRequest):
             detail="A plan with this name already exists",
         )
 
-    # Create a new plan
+    if request.is_promo:
+        plan = await Plan.create(
+            name=request.name,
+            amount=request.amount,
+            duration=request.duration,
+            download_speed=request.download_speed,
+            upload_speed=request.upload_speed,
+            is_promo=request.is_promo,
+        )
+        await plan.set_expiration()
+        await plan.save()
+
+        return BaseResponse(
+            code=200,
+            message="Plan created successfully",
+            payload={"plan_id": str(plan.id)},
+        )
+
+    # Create a new plan not promo
     plan = await Plan.create(
         name=request.name,
         amount=request.amount,

App/Plans/Schema.py

@@ -15,6 +15,8 @@ class CreatePlanRequest(BaseModel):
     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")
+    is_promo: Optional[bool] = Field(..., description="is it a promo", default=False)
+    promo_days: Optional[int] = Field(..., description="promotion days", default=None)
 
 
 class UpdatePlanRequest(BaseModel):

App/Users/Model.py

@@ -5,6 +5,8 @@ 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
+from App.Subscriptions.Model import Subscription
+from App.Plans.Model import Plan
 import datetime
 import uuid
 import random
@@ -56,6 +58,15 @@ class User(models.Model):
         """Hashes a plain password."""
         return pwd_context.hash(plain_password)
 
+    async def send_message(self, message: str):
+        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 verify_password(self, plain_password: str) -> bool:
         """
         Verifies a plain password against the hashed password.
@@ -144,10 +155,19 @@ class User(models.Model):
                 )
                 logger.error(f"Error creating user: {e}")
                 raise e
-
-                # Create the user in the database
             new_user = await cls.create(**user_data)
             logger.info(f"User {new_user.phoneNumber} created successfully.")
+            # if there is a promotion and activate the user
+            promo_plans = await Plan.filter(is_promo=True).all()
+            for promo_plan in promo_plans:
+                plan_valid = await promo_plan.is_promo_valid()
+                if plan_valid:
+                    Subscription.create()
+                    await new_user.activate_user()
+                    await new_user.send_plan_subscription_message(promo_plan)
+
+            # Create the user in the database
+
             # Decide whether to rollback user creation or proceed
             # For simplicity, we'll proceed
 
@@ -159,16 +179,32 @@ class User(models.Model):
             logger.error(f"Error creating user: {e}")
             raise e
 
+    async def send_plan_subscription_message(self, plan: Plan):
+        message = self.message_templates.subscription_created_message(
+            user_name=self.name, plan_name=plan.name
+        )
+        await self.send_message(message=message)
+
+    async def create_subscription(self, plan: Plan):
+        expiration_time = datetime.datetime.now() + datetime.timedelta(
+            hours=plan.duration
+        )
+        # Create the subscription
+        await Subscription.create(
+            user=self,
+            duration=plan.duration,
+            download_mb=plan.download_speed * 1024,
+            upload_mb=plan.upload_speed * 1024,
+            created_time=datetime.datetime.now(),
+            expiration_time=expiration_time,
+            active=True,
+        )
+        await self.activate_user()
+
     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}")
+        await self.send_message(message=message)
 
     async def send_reset_token_message(self):
         """Sends the reset token to the user's phone number."""
@@ -261,5 +297,20 @@ class User(models.Model):
                 f"Failed to send insufficient funds message to {self.phoneNumber}: {e}"
             )
 
-    async def delete_user(self):
-        pass
+    async def activate_user(self):
+        """Activate the user using the Android client."""
+        try:
+            response = await self.android_client.activate_user(self.phoneNumber)
+            if response.get("status") == "success":
+                logger.info(f"User {self.phoneNumber} activated successfully.")
+                self.account_locked = False  # Assuming activation unlocks the account
+                await self.save()
+                return True
+            else:
+                logger.error(
+                    f"Failed to activate user {self.phoneNumber}: {response.get('message')}"
+                )
+                return False
+        except Exception as e:
+            logger.error(f"Error activating user {self.phoneNumber}: {str(e)}")
+            return False