Implement user onboarding flow

src/controllers/_bot_controller.py

@@ -1,8 +1,10 @@
 import os
 from fastapi import APIRouter, HTTPException
+from fastapi.responses import RedirectResponse
 from slack_sdk.web.async_client import AsyncWebClient
 from fastapi import Request
 from src.utils import SlackClient
+from src.services import SlackBotService, SlackTeamService, UserService
 
 from src.utils import logger
 
@@ -14,6 +16,7 @@ class BotController:
         self.router.add_api_route("/event", self.receiveEvent, methods=["POST"])
         self.router.add_api_route("/auth", self.authenticate, methods=["GET"])
         self.router.add_api_route("/frequency", self.updateFrequency, methods=["POST"])
+        self.router.add_api_route("/install", self.install, methods=["GET"])
 
     async def receiveEvent(self, event: dict):
         logger.info(f"Received event: {event}")
@@ -44,16 +47,41 @@ class BotController:
             logger.error(e)
             raise HTTPException(status_code=500, detail=str(e))
 
-    async def authenticate(self, code: str):
+    async def authenticate(self, code: str, state: str):
         try:
-            response = await self.client.oauth_v2_access(
-                client_id=os.environ.get("SLACK_CLIENT_ID"),
-                client_secret=os.environ.get("SLACK_CLIENT_SECRET"),
-                code=code,
-                redirect_uri=os.environ.get("SLACK_REDIRECT_URI"),
-            )
-            logger.info(f"Authenticated successfully: {response}")
-            return {"message": "Token authenticated successfully"}
+            async with SlackBotService() as slack_bot_service:
+                auth_response = await slack_bot_service.handle_oauth_callback(
+                    code, state
+                )
+                if "access_token" in auth_response:
+                    async with SlackTeamService() as slack_team_service:
+                        team = await slack_team_service.get_team_by_slack_team_id(
+                            auth_response["team"]["id"]
+                        )
+                        if not team:
+                            team = await slack_team_service.register_slackTeam(
+                                {
+                                    "name": auth_response["team"]["name"],
+                                    "slack_team_id": auth_response["team"]["id"],
+                                    "token": auth_response["access_token"],
+                                }
+                            )
+                        logger.info(f"Registered team: {team}")
+                        team_users = await slack_bot_service.get_users_list(team.token)
+                        for slack_user in team_users:
+                            async with UserService() as user_service:
+                                user = await user_service.get_user_info_by_email(
+                                    slack_user["profile"]["email"]
+                                )
+                                if user and hasattr(user, "id"):
+                                    await user_service.update_user_slack_info(
+                                        user.id,
+                                        {
+                                            "slack_team_id": team.id,
+                                            "slack_id": slack_user["id"],
+                                        },
+                                    )
+            return {"message": "installed successfully"}
         except HTTPException as e:
             logger.warning(e)
             raise e
@@ -76,3 +104,15 @@ class BotController:
         except Exception as e:
             logger.error(e)
             raise HTTPException(status_code=500, detail=str(e))
+
+    async def install(self):
+        try:
+            async with SlackBotService() as slack_bot_service:
+                auth_url = await slack_bot_service.generate_auth_url()
+                return RedirectResponse(url=auth_url)
+        except HTTPException as e:
+            logger.warning(e)
+            raise e
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))

src/repositories/_base_repository.py

@@ -60,7 +60,7 @@ class BaseRepository:
                 return result
             raise Exception(f"{self.__model.__name__} not found")
 
-    async def patch(self, id, **kwargs: dict):
+    async def patch(self, id, kwargs: dict):
         async with self.get_session() as session:
             instance = await session.get(self.__model, id)
             if instance:

src/repositories/_slack_team_repository.py

@@ -6,3 +6,9 @@ from ._base_repository import BaseRepository
 class SlackTeamRepository(BaseRepository):
     def __init__(self):
         super().__init__(model=SlackTeam)
+
+    async def get_by_slack_team_id(self, slack_team_id: str):
+        query = self.model.select().where(self.model.slack_team_id == slack_team_id)
+        result = await self.execute(query)
+        result = result.scalar_one_or_none()
+        return result

src/repositories/_user_repository.py

@@ -10,7 +10,7 @@ class UserRepository(BaseRepository):
         super().__init__(model=User)
 
     async def get_user_by_email(self, email: str):
-        query = select(User).where(User.email == email)
+        query = select(User).where(User.email_id == email)
         result = await self.execute(query)
         result = result.scalar_one_or_none()
         return result

src/services/__init__.py

@@ -1,6 +1,8 @@
 from ._content_delivery_service import ContentDeliveryService
 from ._user_service import UserService
+from ._slack_bot_service import SlackBotService
+from ._slack_team_service import SlackTeamService
 
-__all__ = ["ContentDeliveryService", "UserService"]
+__all__ = ["ContentDeliveryService", "UserService", "SlackBotService"]
 __version__ = "0.1.0"
 __author__ = "Ashok Bhati"

src/services/_slack_bot_service.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+import os
+
+from fastapi import HTTPException
+from src.utils import logger, SlackClient
+from slack_sdk.oauth import AuthorizeUrlGenerator
+from slack_sdk.oauth.installation_store import FileInstallationStore
+from slack_sdk.oauth.state_store import FileOAuthStateStore
+
+SCOPES = [
+    "chat:write",
+    "chat:write.customize",
+    "commands",
+    "files:read",
+    "im:write",
+    "users:read",
+    "users:read.email",
+]
+
+
+class SlackBotService:
+
+    def __init__(self):
+        self.state_store = FileOAuthStateStore(
+            expiration_seconds=300,
+            base_dir="./slack_state",
+        )
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    async def generate_auth_url(self):
+        state = self.state_store.issue()
+
+        url_generator = AuthorizeUrlGenerator(
+            client_id=os.environ.get("SLACK_CLIENT_ID"),
+            redirect_uri=os.getenv("SLACK_REDIRECT_URI"),
+            scopes=SCOPES,
+        )
+
+        auth_url = url_generator.generate(state=state)
+        return auth_url
+
+    async def handle_oauth_callback(self, code, state):
+        if not code:
+            raise HTTPException(status_code=400, detail="Missing authorization code")
+
+        if not state:
+            raise HTTPException(status_code=400, detail="Missing state parameter")
+
+        if not self.state_store.consume(state):
+            raise HTTPException(status_code=400, detail="Invalid state parameter")
+        async with SlackClient() as slack_client:
+            response = await slack_client.handle_oauth_callback(code=code)
+        return response
+
+    async def get_users_list(self, token):
+        logger.info(f"Getting users list with token: {token}")
+        async with SlackClient(token) as slack_client:
+            response = await slack_client.get_users_list()
+            return response

src/services/_slack_team_service.py

@@ -1,7 +1,7 @@
 from src.repositories import SlackTeamRepository
 
 from src.models import ContentDeliveryFrequency
-import datetime
+from src.utils import logger
 
 
 class SlackTeamService:
@@ -14,10 +14,10 @@ class SlackTeamService:
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         pass
 
-    async def register_slackTeam(self, email: str):
-        return await self.slackTeam_repository.create(email=email)
+    async def register_slackTeam(self, team: dict):
+        logger.info(f"Registering team: {team}")
+        return await self.slackTeam_repository.create(team)
 
     async def get_slackTeam_token(self, slackTeam_id):
-        return await self.slackTeam_repository.get(
-            slackTeam_id, filter_by={"token": True}
-        )
+        team = await self.slackTeam_repository.get_by_slack_team_id(slackTeam_id)
+        return team["token"] if team else None

src/utils/_slack_client.py

@@ -7,8 +7,8 @@ from src.utils import logger
 
 class SlackClient:
 
-    def __init__(self):
-        self.client = AsyncWebClient(token=os.environ.get("SLACK_BOT_TOKEN"))
+    def __init__(self, token: str = None):
+        self.client = AsyncWebClient(token=token)
 
     async def __aenter__(self):
         return self
@@ -35,8 +35,20 @@ class SlackClient:
         return file_info
 
     async def get_users_list(self):
+        logger.info("Getting users list...")
         users_list = await self.client.users_list()
+        logger.info(f"Users list: {users_list}")
         filtered_users = [
-            user for user in users_list["members"] if user["is_bot"] == True
+            user
+            for user in users_list["members"]
+            if user["is_bot"] == False and "email" in user["profile"]
         ]
         return filtered_users
+
+    async def handle_oauth_callback(self, code):
+        return await self.client.oauth_v2_access(
+            client_id=os.environ.get("SLACK_CLIENT_ID"),
+            client_secret=os.environ.get("SLACK_CLIENT_SECRET"),
+            code=code,
+            redirect_uri=os.environ.get("SLACK_REDIRECT_URI"),
+        )