Added participants who have expressed interest in a specific issue in issue model .

backend/Makefile

@@ -1,5 +1,6 @@
 include backend/apps/ai/Makefile
 include backend/apps/github/Makefile
+include backend/apps/mentorship/Makefile
 include backend/apps/nest/Makefile
 include backend/apps/owasp/Makefile
 include backend/apps/slack/Makefile

backend/apps/github/admin/__init__.py

@@ -1,5 +1,6 @@
 """Github app admin."""
 
+from .comment import CommentAdmin
 from .issue import IssueAdmin
 from .label import LabelAdmin
 from .milestone import MilestoneAdmin

backend/apps/github/admin/comment.py

@@ -0,0 +1,21 @@
+"""GitHub app Comment model admin."""
+
+from django.contrib import admin
+
+from apps.github.models import Comment
+
+
+class CommentAdmin(admin.ModelAdmin):
+    """Admin for Comment model."""
+
+    list_display = (
+        "body",
+        "author",
+        "created_at",
+        "updated_at",
+    )
+    list_filter = ("created_at", "updated_at")
+    search_fields = ("body", "author__login")
+
+
+admin.site.register(Comment, CommentAdmin)

backend/apps/github/common.py

@@ -8,6 +8,7 @@
 from django.utils import timezone
 from github.GithubException import UnknownObjectException
 
+from apps.github.models.comment import Comment
 from apps.github.models.issue import Issue
 from apps.github.models.label import Label
 from apps.github.models.milestone import Milestone
@@ -227,3 +228,116 @@ def sync_repository(
     )
 
     return organization, repository
+
+
+def sync_issue_comments(gh_client, issue: Issue):
+    """Sync new comments for a mentorship program specific issue on-demand.
+
+    Args:
+        gh_client (Github): GitHub client.
+        issue (Issue): The local database Issue object to sync comments for.
+
+    """
+    logger.info("Starting comment sync for issue #%s", issue.number)
+
+    try:
+        if not (repository := issue.repository):
+            logger.warning("Issue #%s has no repository, skipping", issue.number)
+            return
+
+        logger.info("Fetching repository: %s", repository.path)
+
+        gh_repository = gh_client.get_repo(repository.path)
+        gh_issue = gh_repository.get_issue(number=issue.number)
+
+        since = issue.last_comment_sync
+        if not since:
+            last_comment = issue.latest_comment
+            since = last_comment.created_at if last_comment else None
+
+        if since:
+            logger.info("Found last comment at: %s, fetching newer comments", since)
+        else:
+            logger.info("No existing comments found, fetching all comments")
+
+        existing_comments = {c.github_id: c for c in issue.comments.select_related("author").all()}
+        comments_to_save = []
+        comments_to_update = []
+        current_time = timezone.now()
+
+        gh_comments = gh_issue.get_comments(since=since) if since else gh_issue.get_comments()
+
+        for gh_comment in gh_comments:
+            existing_comment = existing_comments.get(gh_comment.id)
+
+            if existing_comment:
+                if since and gh_comment.updated_at <= since:
+                    logger.info("Skipping unchanged comment %s", gh_comment.id)
+                    continue
+
+                author = User.update_data(gh_comment.user)
+                if author:
+                    existing_comment.from_github(gh_comment, author=author)
+                    comments_to_update.append(existing_comment)
+                    logger.info(
+                        "Prepared update for comment %s on issue #%s", gh_comment.id, issue.number
+                    )
+                else:
+                    logger.warning("Could not sync author for comment update %s", gh_comment.id)
+            else:
+                if since and gh_comment.created_at <= since:
+                    logger.info(
+                        "Skipping comment %s - not newer than our last sync", gh_comment.id
+                    )
+                    continue
+
+                author = User.update_data(gh_comment.user)
+                if author:
+                    comment = Comment.update_data(gh_comment, author=author, save=False)
+                    comments_to_save.append(comment)
+                    logger.info(
+                        "Prepared new comment %s for issue #%s", gh_comment.id, issue.number
+                    )
+                else:
+                    logger.warning("Could not sync author for comment %s", gh_comment.id)
+
+        if comments_to_save:
+            new_comment_github_ids = [c.github_id for c in comments_to_save]
+
+            Comment.bulk_save(comments_to_save)
+
+            newly_saved_comments = Comment.objects.filter(github_id__in=new_comment_github_ids)
+
+            issue.comments.add(*newly_saved_comments)
+
+            logger.info(
+                "Synced and associated %d new comments for issue #%s",
+                newly_saved_comments.count(),
+                issue.number,
+            )
+
+        if comments_to_update:
+            Comment.bulk_save(comments_to_update)
+            logger.info(
+                "Updated %d existing comments for issue #%s",
+                len(comments_to_update),
+                issue.number,
+            )
+
+        issue.last_comment_sync = current_time
+        issue.save(update_fields=["last_comment_sync"])
+
+        if not comments_to_save and not comments_to_update:
+            logger.info("No new or updated comments found for issue #%s", issue.number)
+
+    except UnknownObjectException as e:
+        logger.warning(
+            "Could not access issue #%s. Error: %s",
+            issue.number,
+            str(e),
+        )
+    except Exception:
+        logger.exception(
+            "An unexpected error occurred during comment sync for issue #%s",
+            issue.number,
+        )

backend/apps/github/migrations/0036_comment_issue_comments.py

@@ -0,0 +1,47 @@
+# Generated by Django 5.2.4 on 2025-09-05 22:55
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("github", "0035_alter_user_bio_alter_user_is_owasp_staff"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Comment",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                ("github_id", models.BigIntegerField(unique=True)),
+                ("body", models.TextField()),
+                ("created_at", models.DateTimeField(db_index=True)),
+                ("updated_at", models.DateTimeField(db_index=True)),
+                (
+                    "author",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="comments",
+                        to="github.user",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Comment",
+                "verbose_name_plural": "Comments",
+                "ordering": ("-created_at",),
+            },
+        ),
+        migrations.AddField(
+            model_name="issue",
+            name="comments",
+            field=models.ManyToManyField(blank=True, related_name="issues", to="github.comment"),
+        ),
+    ]

backend/apps/github/migrations/0037_issue_last_comment_sync.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.2.4 on 2025-09-07 17:45
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("github", "0036_comment_issue_comments"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="issue",
+            name="last_comment_sync",
+            field=models.DateTimeField(
+                blank=True, db_index=True, null=True, verbose_name="Last comment sync"
+            ),
+        ),
+    ]

backend/apps/github/models/__init__.py

@@ -1,5 +1,6 @@
 """Github app."""
 
+from .comment import Comment
 from .milestone import Milestone
 from .pull_request import PullRequest
 from .user import User

backend/apps/github/models/comment.py

@@ -0,0 +1,71 @@
+"""GitHub app comment model."""
+
+from django.db import models
+
+from apps.common.models import BulkSaveModel
+
+
+class Comment(BulkSaveModel, models.Model):
+    """Represents a comment on a GitHub Issue."""
+
+    class Meta:
+        verbose_name = "Comment"
+        verbose_name_plural = "Comments"
+        ordering = ("-created_at",)
+
+    github_id = models.BigIntegerField(unique=True)
+    author = models.ForeignKey(
+        "github.User", on_delete=models.SET_NULL, null=True, related_name="comments"
+    )
+    body = models.TextField()
+    created_at = models.DateTimeField(db_index=True)
+    updated_at = models.DateTimeField(db_index=True)
+
+    def __str__(self):
+        """Return a string representation of the comment."""
+        return f"{self.author} - {self.body[:40]}"
+
+    def from_github(self, gh_comment, author=None):
+        """Populate fields from a GitHub API comment object."""
+        field_mapping = {
+            "body": "body",
+            "created_at": "created_at",
+            "updated_at": "updated_at",
+        }
+
+        for model_field, gh_field in field_mapping.items():
+            value = getattr(gh_comment, gh_field, None)
+            if value is not None:
+                setattr(self, model_field, value)
+
+        self.author = author
+
+    @staticmethod
+    def bulk_save(comments, fields=None):  # type: ignore[override]
+        """Bulk save comments."""
+        BulkSaveModel.bulk_save(Comment, comments, fields=fields)
+
+    @staticmethod
+    def update_data(gh_comment, *, author=None, save: bool = True):
+        """Update or create a Comment instance from a GitHub comment object.
+
+        Args:
+            gh_comment (github.IssueComment.IssueComment): GitHub comment object.
+            author (User, optional): Comment author. Defaults to None.
+            save (bool, optional): Whether to save the instance immediately. Defaults to True.
+
+        Returns:
+            Comment: The updated or newly created Comment instance.
+
+        """
+        try:
+            comment = Comment.objects.get(github_id=gh_comment.id)
+        except Comment.DoesNotExist:
+            comment = Comment(github_id=gh_comment.id)
+
+        comment.from_github(gh_comment, author=author)
+
+        if save:
+            comment.save()
+
+        return comment

backend/apps/github/models/issue.py

@@ -44,6 +44,9 @@ class Meta:
     )
 
     comments_count = models.PositiveIntegerField(verbose_name="Comments", default=0)
+    last_comment_sync = models.DateTimeField(
+        verbose_name="Last comment sync", blank=True, null=True, db_index=True
+    )
 
     # FKs.
     author = models.ForeignKey(
@@ -54,6 +57,13 @@ class Meta:
         null=True,
         related_name="created_issues",
     )
+
+    comments = models.ManyToManyField(
+        "github.Comment",
+        related_name="issues",
+        blank=True,
+    )
+
     milestone = models.ForeignKey(
         "github.Milestone",
         on_delete=models.CASCADE,
@@ -83,6 +93,16 @@ class Meta:
         blank=True,
     )
 
+    @property
+    def latest_comment(self):
+        """Get the latest comment for this issue.
+
+        Returns:
+            Comment | None: The most recently created comment, or None if no comments exist.
+
+        """
+        return self.comments.order_by("-created_at").first()
+
     def from_github(self, gh_issue, *, author=None, milestone=None, repository=None):
         """Update the instance based on GitHub issue data.
 

backend/apps/mentorship/Makefile

@@ -0,0 +1,3 @@
+mentorship-update-comments:
+	@echo "Syncing Github Comments related to issues"
+	@CMD="python manage.py mentorship_update_comments --verbosity 2" $(MAKE) exec-backend-command

backend/apps/mentorship/admin/__init__.py

@@ -1,5 +1,6 @@
 """Mentorship app admin."""
 
+from .issue_user_interest import IssueUserInterest
 from .mentee import MenteeAdmin
 from .mentee_program import MenteeProgramAdmin
 from .mentor import MentorAdmin

backend/apps/mentorship/admin/issue_user_interest.py

@@ -0,0 +1,16 @@
+"""Mentorship app IssueUserInterest admin."""
+
+from django.contrib import admin
+
+from apps.mentorship.models import IssueUserInterest
+
+
+class IssueUserInterestAdmin(admin.ModelAdmin):
+    """IssueUserInterest admin."""
+
+    list_display = ("module", "issue")
+    search_fields = ("module__name", "user__login", "issue__title")
+    list_filter = ("module",)
+
+
+admin.site.register(IssueUserInterest, IssueUserInterestAdmin)