Merge pull request #4 from Jeewhan/feature/community

출석체크: 다진마늘, 책읽어또

Author: Jeewhan

.envrc

@@ -0,0 +1 @@
+source .venv/bin/activate

.github/workflows/push.yml

@@ -0,0 +1,50 @@
+name: Push
+
+on:
+  schedule:
+    - cron: "0 20 * * *" # UTC 20:00 = KST 05:00
+  workflow_dispatch:
+
+jobs:
+  check-attendance:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: "read"
+      id-token: "write"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.12"
+
+      - name: Install Poetry
+        run: |
+          python -m pip install poetry
+
+      - name: Install dependencies
+        run: |
+          poetry install --no-interaction --no-root
+
+      - name: Run attendance checks
+        run: |
+          echo "::group::Book Read Check"
+          poetry run python push.py 책읽어또
+          echo "::endgroup::"
+
+          echo "::group::Garlic Check"
+          poetry run python push.py 다진마늘
+          echo "::endgroup::"
+        env:
+          SHEETS_ID: ${{ secrets.SHEETS_ID }}
+          GEULTTO_SLACK_TOKEN: ${{ secrets.GEULTTO_SLACK_TOKEN }}
+          PROJECT_ID: ${{ secrets.PROJECT_ID }}
+          PRIVATE_KEY_ID: ${{ secrets.PRIVATE_KEY_ID }}
+          PRIVATE_KEY: ${{ secrets.PRIVATE_KEY }}
+          CLIENT_EMAIL: ${{ secrets.CLIENT_EMAIL }}
+          CLIENT_ID: ${{ secrets.CLIENT_ID }}
+          CLIENT_X509_CERT_URL: ${{ secrets.CLIENT_X509_CERT_URL }}
+          MINCED_GARLIC_CHANNEL_ID: ${{ vars.MINCED_GARLIC_CHANNEL_ID }}
+          BOOK_READ_CHANNEL_ID: ${{ vars.BOOK_READ_CHANNEL_ID }}

.gitignore

@@ -23,4 +23,7 @@ __pycache__
 
 *.zip
 
-app/slack/**
+app/slack/**
+
+.direnv
+.env

app/adapter/output/slack.py

@@ -1,19 +1,25 @@
 import logging
 
-from slack_sdk import WebClient
+from typing import TypeVar
+from slack_sdk.web.client import WebClient
 from slack_sdk.errors import SlackApiError
 
 
+T = TypeVar("T")
+
+
 class SlackClient:
-    def __init__(self, token):
+    def __init__(self, token: str) -> None:
         self.client = WebClient(token)
 
-    def __get_response(self, response):
+    def __get_response(self, response: T) -> T:
         if not response["ok"]:
             raise SlackApiError(response["error"])
         return response
 
-    def get_member_id_by_channel(self, channel_id, cursor=None):
+    def get_member_id_by_channel(
+        self, channel_id: str, cursor: None | str = None
+    ) -> list[str]:
         response = self.client.conversations_members(channel=channel_id, cursor=cursor)
         response = self.__get_response(response)
 
@@ -26,7 +32,7 @@ def get_member_id_by_channel(self, channel_id, cursor=None):
             member_id += self.get_member_id_by_channel(channel_id, next_cursor)
         return member_id
 
-    def get_reaction_members(self, channel_id, timestamp):
+    def get_reaction_members(self, channel_id: str, timestamp: str) -> set[str]:
         response = self.client.reactions_get(channel=channel_id, timestamp=timestamp)
         response = self.__get_response(response)
 
@@ -42,7 +48,9 @@ def get_reaction_members(self, channel_id, timestamp):
             user_id.update(reaction["users"])
         return user_id
 
-    def post_remind_message(self, channel_id, timestamp, users):
+    def post_remind_message(
+        self, channel_id: str, timestamp: str, users: list[str]
+    ) -> None:
         user_list = ""
         for user in users:
             user_list += "<@" + user + "> "
@@ -55,7 +63,9 @@ def post_remind_message(self, channel_id, timestamp, users):
         response = self.__get_response(response)
         return
 
-    def post_message(self, channel_id, user, timestamp, message):
+    def post_message(
+        self, channel_id: str, user: str, timestamp: str, message: str
+    ) -> None:
         response = self.client.chat_postMessage(
             channel=channel_id,
             text=message,
@@ -66,14 +76,69 @@ def post_message(self, channel_id, user, timestamp, message):
         response = self.__get_response(response)
         return
 
-    def is_bot_user(self, user):
+    def is_bot_user(self, user: str) -> bool:
         response = self.client.users_info(user=user)
         response = self.__get_response(response)
         return response["user"].get("is_bot")
 
-    def get_message_info(self, channel_id, timestamp):
+    def get_message_info(self, channel_id: str, timestamp: str) -> str:
         response = self.client.conversations_history(
             channel=channel_id, oldest=timestamp, limit=1, inclusive=True
         )
         response = self.__get_response(response)
         return response["messages"][0]["text"]
+
+    def get_conversation_history(
+        self,
+        channel_id: str,
+        *,
+        limit: int = 200,
+        oldest: None | str = None,
+        latest: None | str = None,
+    ) -> list[dict]:
+        response = self.client.conversations_history(
+            channel=channel_id, limit=limit, oldest=oldest, latest=latest
+        )
+        return self.__get_response(response)
+
+    def get_all_conversation_histories(
+        self,
+        channel_id: str,
+        *,
+        limit: int = 200,
+        oldest: None | str = None,
+        latest: None | str = None,
+    ) -> list[dict]:
+        all_messages = []
+        cursor: None | str = None
+
+        while True:
+            response = self.client.conversations_history(
+                channel=channel_id,
+                limit=limit,
+                oldest=oldest,
+                latest=latest,
+                cursor=cursor,
+            )
+
+            all_messages.extend(response["messages"])
+
+            if not (cursor := response.get("response_metadata", {}).get("next_cursor")):
+                break
+
+        return all_messages
+
+    def get_conversations_replies(self, channel_id: str, timestamp: str) -> list[dict]:
+        response = self.client.conversations_replies(channel=channel_id, ts=timestamp)
+        response = self.__get_response(response)
+        return response["messages"]
+
+    def get_conversation_members(self, channel_id: str) -> list[str]:
+        response = self.client.conversations_members(channel=channel_id, limit=1000)
+        response = self.__get_response(response)
+        return response["members"]
+
+    def get_user_name(self, user_id: str) -> str:
+        response = self.client.users_info(user=user_id)
+        response = self.__get_response(response)
+        return response["user"]["real_name"]

app/application/service/push/attendance/attendance_service.py

@@ -0,0 +1,87 @@
+import os
+from gspread import service_account_from_dict, Worksheet
+from typing import Type, TypeVar
+from dataclasses import fields
+from abc import abstractmethod
+from dotenv import load_dotenv
+
+from app.adapter.output.slack import SlackClient
+
+T = TypeVar("T")
+
+
+load_dotenv()
+
+gc = service_account_from_dict(
+    {
+        "type": "service_account",
+        "project_id": os.getenv("PROJECT_ID"),
+        "private_key_id": os.getenv("PRIVATE_KEY_ID"),
+        "private_key": os.getenv("PRIVATE_KEY").replace("\\n", "\n"),
+        "client_email": os.getenv("CLIENT_EMAIL"),
+        "client_id": os.getenv("CLIENT_ID"),
+        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+        "client_x509_cert_url": os.getenv("CLIENT_X509_CERT_URL"),
+        "universe_domain": "googleapis.com",
+    }
+)
+
+
+class AttendanceService:
+    def __init__(self) -> None:
+        if not os.getenv("SHEETS_ID"):
+            raise ValueError("SHEETS_ID is not set")
+        if not os.getenv("GEULTTO_SLACK_TOKEN"):
+            raise ValueError("GEULTTO_SLACK_TOKEN is not set")
+
+        self.slack = SlackClient(os.getenv("GEULTTO_SLACK_TOKEN"))
+        self.sheets = gc.open_by_key(os.getenv("SHEETS_ID"))
+
+    @property
+    def sheet(self) -> Worksheet:
+        if not hasattr(self, "sheet_title") or self.sheet_title is None:
+            raise ValueError("sheet_title is not set")
+        return self.sheets.worksheet(self.sheet_title)
+
+    @abstractmethod
+    def check(self) -> None:
+        pass
+
+    @classmethod
+    def convert_records_to_models(
+        cls, records: list[dict[str, object]], model: Type[T]
+    ) -> list[T]:
+        return [
+            model(
+                **{
+                    k: v
+                    for k, v in record.items()
+                    if k in {f.name for f in fields(model)}
+                }
+            )
+            for record in records
+        ]
+
+    def get_sheet_records_to(self, model: Type[T]) -> list[T]:
+        records = self.sheet.get_all_records()
+        return self.convert_records_to_models(records, model)
+
+    def update_members(self) -> None:
+        if not hasattr(self, "slack_channel_id") or self.slack_channel_id is None:
+            raise ValueError("slack_channel_id is not set")
+
+        sheet = self.sheets.worksheet("참여자")
+
+        sheet_records = {record["user"] for record in sheet.get_all_records()}
+        slack_records = set(self.slack.get_conversation_members(self.slack_channel_id))
+
+        missing_records = slack_records - sheet_records
+
+        rows_to_append = [
+            [user, self.slack.get_user_name(user)] for user in missing_records
+        ]
+
+        if rows_to_append:
+            sheet.append_rows(rows_to_append)