done

App/Android/Android.py

@@ -49,6 +49,16 @@ class AndroidClient:
         response = await self.client.post(f"/logout/{phone}")
         return APIResponse(**response.json())
 
+    @require_base_url
+    async def is_user_active(self, phone_number):
+        """Retrieve all active users."""
+        response = await self.client.get("/users/active")
+        active_users = response.json()["active_users"]
+
+        for user in active_users:
+            if phone_number == user["phone"]:
+                return True
+
     @require_base_url
     async def get_active_users(self) -> APIResponse:
         """Retrieve all active users."""
@@ -57,8 +67,15 @@ class AndroidClient:
         return APIResponse(**response.json())
 
     @require_base_url
-    async def disable_user(self, request: SetUserStatusRequest) -> APIResponse:
+    async def remove_session(self, phone_number) -> APIResponse:
         """Enable or disable a user."""
+        path = f"/users/{phone_number}/remove-session"
+        response = await self.client.post(path, json=None)
+        return APIResponse(**response.json())
+
+    @require_base_url
+    async def disable_user(self, request: SetUserStatusRequest) -> APIResponse:
+        """disable a user."""
         path = f"/users/{request.phone}/disable"
         response = await self.client.post(path, json=None)
         return APIResponse(**response.json())
@@ -112,3 +129,9 @@ class AndroidClient:
         await self.enable_user(request=request)
         # Replace this with actual API call logic
         return {"status": "success", "message": "User activated."}
+
+    async def deactivate_user(self, phone_number: str):
+        request = SetUserStatusRequest(phone=phone_number, disabled=False)
+        await self.disable_user(request=request)
+        # Replace this with actual API call logic
+        return {"status": "success", "message": "User activated."}

App/Subscriptions/SubscriptionRoutes.py

@@ -145,13 +145,29 @@ async def update_usage(subscription_id: str, request: UpdateUsageRequest):
     "/subscription/{subscription_id}/deactivate", response_model=BaseResponse
 )
 async def deactivate_subscription(subscription_id: str):
+    # Fetch the subscription by ID
     subscription = await Subscription.get_or_none(id=subscription_id)
     if not subscription:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="Subscription not found"
         )
 
+    # Fetch the associated user
+    user = await subscription.user
+    plan = await subscription.plan
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found for subscription",
+        )
+
+    # Deactivate the subscription
     subscription.active = False
     await subscription.save()
 
-    return BaseResponse(code=200, message="Subscription deactivated successfully")
+    # Deactivate the user associated with this subscription
+    await user.deactivate_user()
+    await user.send_subcription_expired_message(plan=plan)
+    return BaseResponse(
+        code=200, message="Subscription and user deactivated successfully"
+    )

App/Templates/Templates.py

@@ -61,5 +61,8 @@ class MessageTemplate:
     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}."
 
-
-    
+    def subscription_expired_message(
+        self, user_name: str, plan_name: str, business_name=BUSINESS
+    ) -> str:
+        """Generates a message when the subscription is over."""
+        return f"Habari {user_name}, Bando lako la {plan_name}, limeisha. "

App/Users/Model.py

@@ -318,3 +318,41 @@ class User(models.Model):
         except Exception as e:
             logger.error(f"Error activating user {self.phoneNumber}: {str(e)}")
             return False
+
+    async def deactivate_user(self):
+
+        self.account_locked = True
+        await self.save()
+        await self.remover_user_session()
+
+        try:
+            await self.android_client.deactivate_user(self.phoneNumber)
+        except Exception as e:
+            logger.error(f"Failed to deactivate user {self.phoneNumber}: {e}")
+            raise e  # Raise the error after logging
+
+    async def send_subcription_expired_message(self, plan: Plan):
+        try:
+            message = self.message_templates.subscription_expired_message(
+                user_name=self.name, plan_name=plan.name
+            )
+            await self.send_message(message=message)
+            logger.info(f"Subscription expired message sent to {self.phoneNumber}.")
+        except Exception as e:
+            logger.error(
+                f"Failed to send subscription expired message to {self.phoneNumber}: {e}"
+            )
+            raise e
+
+    async def is_active(self):
+        try:
+            return await self.android_client.is_user_active(self.phoneNumber)
+        except Exception as e:
+            raise e
+
+    async def remover_user_session(self):
+        try:
+            await self.android_client.remove_session(self.phoneNumber)
+        except Exception as e:
+            logger.error(f"Failed to remove session for {self.phoneNumber}: {e}")
+            raise e  #  Raise the error after logging

App/Users/UserRoutes.py

@@ -63,10 +63,11 @@ async def register_user(request: RegisterUserRequest):
 )
 async def login_user(request: LoginUserRequest):
     # Find user by phone number
-    db_user = await User.filter(phoneNumber=request.phoneNumber).first()
+    db_user: User = await User.filter(phoneNumber=request.phoneNumber).first()
     valid_password = await db_user.verify_password(request.password)
     # Check if user exists and password is correct
     if db_user and valid_password:
+
         # Fetch active subscription if it exists
         subscription = await Subscription.filter(user=db_user, active=True).first()
 
@@ -75,6 +76,9 @@ async def login_user(request: LoginUserRequest):
             subscription.expiration_time.isoformat() if subscription else None
         )
 
+        is_active = await db_user.is_active()
+        if is_active:
+            await db_user.remover_user_session()
         access_token = create_access_token(
             data={
                 "user_name": db_user.name,
@@ -145,17 +149,17 @@ async def get_all_users():
     return [UserResponse.from_orm(user) for user in users]
 
 
-@user_router.delete(
-    "/user/{user_id}", response_model=BaseResponse, status_code=status.HTTP_200_OK
-)
-async def delete_user(user_id: str):
-    user = await User.filter(id=user_id).first()
-    if not user:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail="User not found."
-        )
-    await user.delete()
-    return BaseResponse(code=200, message="User deleted successfully.")
+# @user_router.delete(
+#     "/user/{user_id}", response_model=BaseResponse, status_code=status.HTTP_200_OK
+# )
+# async def delete_user(user_id: str):
+#     user = await User.filter(id=user_id).first()
+#     if not user:
+#         raise HTTPException(
+#             status_code=status.HTTP_404_NOT_FOUND, detail="User not found."
+#         )
+#     await user.delete()
+#     return BaseResponse(code=200, message="User deleted successfully.")
 
 
 @user_router.put(