add experimental github support

Author: artcz

deploy/templates/app/intbot.env.example

@@ -14,6 +14,9 @@ DISCORD_BOT_TOKEN="Token Goes Here"
 DISCORD_TEST_CHANNEL_ID="123123123123123123123123"
 DISCORD_TEST_CHANNEL_NAME="#test-channel"
 
-
 # Webhooks
 WEBHOOK_INTERNAL_TOKEN="asdf"
+
+# Github
+GITHUB_API_TOKEN="github-api-token-goes-here"
+GITHUB_WEBHOOK_SECRET_TOKEN="github-webhook-secret-token"

intbot/.env.example

@@ -1,3 +1,8 @@
+# Discord
 DISCORD_BOT_TOKEN='asdf'
 DISCORD_TEST_CHANNEL_ID="123123123123123123123123"
 DISCORD_TEST_CHANNEL_NAME="#test-channel"
+
+# Github
+GITHUB_API_TOKEN="github-api-token"
+GITHUB_WEBHOOK_SECRET_TOKEN="github-webhook-secret-token"

intbot/core/endpoints/__init__.py

@@ -1,9 +1,11 @@
+import hashlib
 import hmac
 import json
 
 from core.models import Webhook
 from core.tasks import process_webhook
 from django.conf import settings
+from django.http import HttpResponseForbidden
 from django.http.response import HttpResponseNotAllowed, JsonResponse
 from django.views.decorators.csrf import csrf_exempt
 
@@ -37,3 +39,49 @@ def verify_internal_webhook(request):
 
     if not hmac.compare_digest(settings.WEBHOOK_INTERNAL_TOKEN, token):
         raise ValueError("Token doesn't match")
+
+
+@csrf_exempt
+def github_webhook_endpoint(request):
+    if request.method == "POST":
+        github_headers = {
+            k: v for k, v in request.headers.items() if k.startswith("X-Github")
+        }
+
+        try:
+            signature = verify_github_signature(request)
+        except ValueError as e:
+            return HttpResponseForbidden(e)
+
+        wh = Webhook.objects.create(
+            source="github",
+            meta=github_headers,
+            signature=signature,
+            content=json.loads(request.body),
+        )
+        process_webhook.enqueue(str(wh.uuid))
+        return JsonResponse({"status": "ok"})
+
+    return HttpResponseNotAllowed("Only POST")
+
+
+def verify_github_signature(request) -> str:
+    """Verify that the payload was sent by github"""
+
+    if "X-Hub-Signature-256" not in request.headers:
+        raise ValueError("X-Hub-Signature-256 is missing")
+
+    signature = request.headers["X-Hub-Signature-256"]
+
+    hashed = hmac.new(
+        settings.GITHUB_WEBHOOK_SECRET_TOKEN.encode("utf-8"),
+        msg=request.body,
+        digestmod=hashlib.sha256,
+    )
+
+    expected = "sha256=" + hashed.hexdigest()
+
+    if not hmac.compare_digest(expected, signature):
+        raise ValueError("Signature's don't match")
+
+    return signature

intbot/core/endpoints/webhooks.py

@@ -0,0 +1,178 @@
+import dataclasses
+
+import httpx
+from django.conf import settings
+
+GITHUB_API_URL = "https://api.github.com/graphql"
+
+# GraphQL query
+query = """
+query($itemId: ID!) {
+  node(id: $itemId) {
+    ... on ProjectV2Item {
+      id
+      content {
+        ... on DraftIssue {
+          id
+          title
+        }
+        ... on Issue {
+          id
+          title
+          url
+        }
+    }
+    }
+  }
+}
+"""
+
+
+def parse_github_webhook(headers: dict, content: dict) -> tuple[str, str]:
+    event = headers["X-Github-Event"]
+
+    if event == "projects_v2_item":
+        parser = GithubProjectV2Item(content)
+        formatted = parser.as_str()
+        action = parser.action()
+        event_action = f"{event}.{action}"
+        return formatted, event_action
+
+    elif event == "...":
+        return "", ""
+
+    else:
+        raise ValueError(f"Event {event} not supported")
+
+
+@dataclasses.dataclass
+class GithubIssue:
+    id: str
+    title: str
+    url: str
+
+    def as_discord_message(self):
+        return f"[{self.title}]({self.url})"
+
+
+@dataclasses.dataclass
+class GithubDraftIssue:
+    id: str
+    title: str
+
+    def as_discord_message(self):
+        return self.title
+
+
+def fetch_github_item_details(item_id):
+    headers = {
+        "Authorization": f"Bearer {settings.GITHUB_TOKEN}",
+        "Content-Type": "application/json",
+    }
+    payload = {"query": query, "variables": {"itemId": item_id}}
+    response = httpx.post(GITHUB_API_URL, json=payload, headers=headers)
+    if response.status_code == 200:
+        return response.json()["data"]["node"]["content"]
+    else:
+        raise Exception(f"GitHub API error: {response.status_code} - {response.text}")
+
+
+CONTENT_TYPE_MAP = {
+    "Issue": GithubIssue,
+    "DraftIssue": GithubDraftIssue,
+}
+
+
+class GithubProjectV2Item:
+    def __init__(self, content: dict):
+        self.content = content
+
+    def action(self):
+        if self.content["action"] == "edited":
+            action = "changed"
+        elif self.content["action"] == "created":
+            action = "created"
+        else:
+            raise ValueError(f"Action unsupported {self.content['action']}")
+
+        return action
+
+    def sender(self):
+        login = self.content["sender"]["login"]
+        url = self.content["sender"]["html_url"]
+
+        return f"[@{login}]({url})"
+
+    def content_type(self):
+        return self.content["projects_v2_item"]["content_type"]
+
+    def node_id(self):
+        # NOTE(artcz): This is more relevant, because of how the graphql query
+        # above is constructed.
+        # Using node_id, which is an id of a ProjectV2Item we can get both
+        # DraftIssue and Issue from one query.
+        # If we use the content_node_id we need to adjust the query as that ID
+        # points us directly either an Issue or DraftIssue
+        return self.content["projects_v2_item"]["node_id"]
+
+    def content_node_id(self):
+        return self.content["projects_v2_item"]["content_node_id"]
+
+    def changes(self) -> dict:
+        if "changes" in self.content:
+            fv = self.content["changes"]["field_value"]
+            field_name = fv["field_name"]
+            field_type = fv["field_type"]
+            if field_type == "date":
+                changed_from = (
+                    fv["from"].split("T")[0] if fv["from"] is not None else "None"
+                )
+                changed_to = fv["to"].split("T")[0] if fv["to"] is not None else "None"
+            elif field_type == "single_select":
+                changed_from = fv["from"]["name"] if fv["from"] is not None else "None"
+                changed_to = fv["to"]["name"] if fv["to"] is not None else "None"
+            else:
+                changed_from = "None"
+                changed_to = "None"
+
+            return {
+                "field": field_name,
+                "from": changed_from,
+                "to": changed_to,
+            }
+
+        return {}
+
+    def as_discord_message(self, github_object: GithubDraftIssue | GithubIssue) -> str:
+        message = "{sender} {action} {details}".format
+
+        action = self.action()
+        sender = self.sender()
+
+        changes = self.changes()
+
+        if changes:
+            details = "**{field}** of **{obj}** from **{from}** to **{to}**".format
+            details = details(**{"obj": github_object.as_discord_message(), **changes})
+
+        else:
+            details = github_object.as_discord_message()
+
+        return message(
+            **{
+                "sender": sender,
+                "action": action,
+                "details": details,
+            }
+        )
+
+    def fetch_quoted_github_object(self) -> GithubIssue | GithubDraftIssue:
+        obj = fetch_github_item_details(self.node_id())
+
+        obj = CONTENT_TYPE_MAP[self.content_type()](**obj)
+
+        return obj
+
+    def as_str(self):
+        github_obj = self.fetch_quoted_github_object()
+        return self.as_discord_message(github_obj)

intbot/core/integrations/__init__.py

@@ -4,15 +4,14 @@
 
 
 class Migration(migrations.Migration):
-
     dependencies = [
-        ('core', '0001_initial_migration'),
+        ("core", "0001_initial_migration"),
     ]
 
     operations = [
         migrations.AlterField(
-            model_name='webhook',
-            name='meta',
+            model_name="webhook",
+            name="meta",
             field=models.JSONField(default=dict),
         ),
     ]

intbot/core/integrations/github.py

@@ -1,6 +1,6 @@
-from django.conf import settings
-
 from core.models import DiscordMessage, Webhook
+from core.integrations.github import parse_github_webhook
+from django.conf import settings
 from django.utils import timezone
 from django_tasks import task
 
@@ -12,6 +12,9 @@ def process_webhook(wh_uuid: str):
     if wh.source == "internal":
         process_internal_webhook(wh)
 
+    elif wh.source == "github":
+        process_github_webhook(wh)
+
     else:
         raise ValueError(f"Unsupported source {wh.source}")
 
@@ -29,3 +32,22 @@ def process_internal_webhook(wh: Webhook):
     )
     wh.processed_at = timezone.now()
     wh.save()
+
+
+def process_github_webhook(wh: Webhook):
+    if wh.source != "github":
+        raise ValueError("Incorrect wh.source = {wh.source}")
+
+    message, event_action = parse_github_webhook(headers=wh.meta, content=wh.content)
+
+    # NOTE WHERE SHOULD WE GET THE CHANNEL ID FROM?
+    DiscordMessage.objects.create(
+        channel_id=settings.DISCORD_TEST_CHANNEL_ID,
+        channel_name=settings.DISCORD_TEST_CHANNEL_NAME,
+        content=f"GitHub: {message}",
+        # Mark as unsend - to be sent with the next batch
+        sent_at=None,
+    )
+    wh.event = event_action
+    wh.processed_at = timezone.now()
+    wh.save()

intbot/core/migrations/0002_test.py

@@ -152,6 +152,8 @@ def warn_if_missing(name, default=""):
     DISCORD_TEST_CHANNEL_ID = warn_if_missing("DISCORD_TEST_CHANNEL_ID", "")
     DISCORD_TEST_CHANNEL_NAME = warn_if_missing("DISCORD_TEST_CHANNEL_NAME", "")
     DISCORD_BOT_TOKEN = warn_if_missing("DISCORD_BOT_TOKEN", "")
+    GITHUB_TOKEN = warn_if_missing("GITHUB_TOKEN", "")
+    GITHUB_WEBHOOK_SECRET_TOKEN = warn_if_missing("GITHUB_WEBHOOK_SECRET_TOKEN", "")
 
 
 elif DJANGO_ENV == "test":
@@ -186,8 +188,11 @@ def warn_if_missing(name, default=""):
         }
     }
 
+    DISCORD_BOT_TOKEN = "test-token"
     DISCORD_TEST_CHANNEL_ID = "12345"
     DISCORD_TEST_CHANNEL_NAME = "#test-channel"
+    GITHUB_TOKEN = "github-test-token"
+    GITHUB_WEBHOOK_SECRET_TOKEN = "github-webhook-secret-token-token"
 
 
 elif DJANGO_ENV == "local_container":
@@ -293,6 +298,8 @@ def warn_if_missing(name, default=""):
     ]
 
     WEBHOOK_INTERNAL_TOKEN = os.environ["WEBHOOK_INTERNAL_TOKEN"]
+    GITHUB_TOKEN = os.environ["GITHUB_TOKEN"]
+    GITHUB_WEBHOOK_SECRET_TOKEN = os.environ["GITHUB_WEBHOOK_SECRET_TOKEN"]
 
 
 elif DJANGO_ENV == "build":

intbot/core/tasks.py

@@ -1,12 +1,12 @@
+from core.endpoints.basic import index
+from core.endpoints.webhooks import github_webhook_endpoint, internal_webhook_endpoint
 from django.contrib import admin
 from django.urls import path
 
-from core.endpoints.basic import index
-from core.endpoints.webhooks import internal_webhook_endpoint
-
 urlpatterns = [
     path("admin/", admin.site.urls),
     path("", index),
     # Internal Webhooks
     path("webhook/internal/", internal_webhook_endpoint),
+    path("webhook/github/", github_webhook_endpoint),
 ]

intbot/intbot/settings.py

@@ -39,5 +39,5 @@ def test_process_webhook_fails_if_unsupported_source(caplog):
     result = process_webhook.enqueue(str(wh.uuid))
 
     assert result.status == ResultStatus.FAILED
-    assert result._exception_class  == ValueError
+    assert result._exception_class == ValueError
     assert result.traceback.endswith("ValueError: Unsupported source asdf\n")