Study Groups: Enable users to form or join virtual study groups where they can invite friends or other users.

[A1L13N]

[A1L13N]

@coderabbitai code

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Get basic repository structure
ls -la
# Look for package.json or similar to identify the tech stack
find . -type f -name "package.json" -o -name "pom.xml" -o -name "requirements.txt" -o -name "Gemfile"

Length of output: 2013

---

🏁 Script executed:

#!/bin/bash
# Examine the web directory structure
ls -la web/
# Look for models.py files to understand the data structure
find web/ -name "models.py"
# Look for views.py files to understand the application logic
find web/ -name "views.py"
# Look for urls.py files to understand the routing
find web/ -name "urls.py"

Length of output: 2638

---

🏁 Script executed:

#!/bin/bash
# Check for user-related models
grep -A 20 "class User" web/models.py || grep -A 20 "class Profile" web/models.py

# Check for any existing social or group-related models
grep -A 20 "class.*Group" web/models.py 

# Check if there's any social.py content that might be relevant
head -n 50 web/social.py

Length of output: 4828

---

🏁 Script executed:

#!/bin/bash
# Check for existing StudyGroup views
grep -A 10 "StudyGroup" web/views.py

# Check for StudyGroup URLs
grep -A 5 "study[_-]group" web/urls.py

# Check for any templates related to study groups
find web/templates -type f -name "*study*group*" -o -name "*group*study*"

Length of output: 1707

---

🏁 Script executed:

#!/bin/bash
# Get the complete study_groups and study_group_detail view functions
grep -n "def study_groups" web/views.py -A 40
grep -n "def study_group_detail" web/views.py -A 40

# Look for any templates with "group" in the name
find web/templates -type f -name "*group*.html"

# Check the course model to understand how it connects to study groups
grep -A 15 "class Course" web/models.py

Length of output: 5591

---

🏁 Script executed:

#!/bin/bash
# Check the templates to understand the UI structure
cat web/templates/web/study/groups.html
cat web/templates/web/study/group_detail.html

# Check for any invitation models in the system (like TeamInvite mentioned earlier)
grep -A 15 "class TeamInvite" web/models.py

Length of output: 13853

---

@A1L13N Based on examining the codebase, I noticed that the basic study group functionality exists, but invitation features are missing. Here's the implementation to enable users to form or join virtual study groups with invitation capabilities:

1. Create a StudyGroupInvite model

# Add to web/models.py
class StudyGroupInvite(models.Model):
    """Invitation to join a study group."""

    group = models.ForeignKey(StudyGroup, on_delete=models.CASCADE, related_name="invites")
    sender = models.ForeignKey(User, on_delete=models.CASCADE, related_name="sent_group_invites")
    recipient = models.ForeignKey(User, on_delete=models.CASCADE, related_name="received_group_invites")
    created_at = models.DateTimeField(auto_now_add=True)
    responded_at = models.DateTimeField(null=True, blank=True)

    STATUS_CHOICES = [("pending", "Pending"), ("accepted", "Accepted"), ("declined", "Declined")]
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default="pending")

    class Meta:
        unique_together = ["group", "recipient"]

    def __str__(self):
        return f"Invitation to {self.group.name} for {self.recipient.username}"

2. Add views for sending and responding to invitations

# Add to web/views.py
@login_required
def invite_to_study_group(request, group_id):
    """Invite a user to a study group."""
    group = get_object_or_404(StudyGroup, id=group_id)
    
    # Check if user is a member of the group
    if request.user not in group.members.all():
        messages.error(request, "You must be a member of the group to invite others.")
        return redirect("study_group_detail", group_id=group.id)
    
    if request.method == "POST":
        email_or_username = request.POST.get("email_or_username")
        
        try:
            # Try to find user by email
            recipient = User.objects.get(email=email_or_username)
        except User.DoesNotExist:
            try:
                # Try to find user by username
                recipient = User.objects.get(username=email_or_username)
            except User.DoesNotExist:
                messages.error(request, f"No user found with email or username: {email_or_username}")
                return redirect("study_group_detail", group_id=group.id)
        
        # Check if user is already a member
        if recipient in group.members.all():
            messages.warning(request, f"{recipient.username} is already a member of this group.")
            return redirect("study_group_detail", group_id=group.id)
        
        # Check if invitation already exists
        if StudyGroupInvite.objects.filter(group=group, recipient=recipient, status="pending").exists():
            messages.warning(request, f"An invitation has already been sent to {recipient.username}.")
            return redirect("study_group_detail", group_id=group.id)
        
        # Create invitation
        invite = StudyGroupInvite.objects.create(
            group=group,
            sender=request.user,
            recipient=recipient
        )
        
        # Send notification
        notification_text = f"{request.user.username} has invited you to join the study group: {group.name}"
        Notification.objects.create(
            user=recipient,
            text=notification_text,
            link=reverse("user_invitations")
        )
        
        messages.success(request, f"Invitation sent to {recipient.username}.")
        return redirect("study_group_detail", group_id=group.id)
    
    return redirect("study_group_detail", group_id=group.id)

@login_required
def user_invitations(request):
    """View and manage study group invitations."""
    # Get pending invitations for the user
    invitations = StudyGroupInvite.objects.filter(
        recipient=request.user,
        status="pending"
    ).select_related("group", "sender")
    
    return render(request, "web/study/invitations.html", {"invitations": invitations})

@login_required
def respond_to_invitation(request, invite_id):
    """Accept or decline a study group invitation."""
    invite = get_object_or_404(StudyGroupInvite, id=invite_id, recipient=request.user)
    
    if request.method == "POST":
        response = request.POST.get("response")
        
        if response == "accept":
            # Add user to group
            invite.group.members.add(request.user)
            invite.status = "accepted"
            invite.responded_at = timezone.now()
            invite.save()
            
            # Send notification to the sender
            notification_text = f"{request.user.username} has accepted your invitation to {invite.group.name}"
            Notification.objects.create(
                user=invite.sender,
                text=notification_text,
                link=reverse("study_group_detail", args=[invite.group.id])
            )
            
            messages.success(request, f"You have joined {invite.group.name}.")
            return redirect("study_group_detail", group_id=invite.group.id)
        
        elif response == "decline":
            invite.status = "declined"
            invite.responded_at = timezone.now()
            invite.save()
            
            # Send notification to the sender
            notification_text = f"{request.user.username} has declined your invitation to {invite.group.name}"
            Notification.objects.create(
                user=invite.sender,
                text=notification_text,
                link=reverse("study_group_detail", args=[invite.group.id])
            )
            
            messages.info(request, f"You have declined the invitation to {invite.group.name}.")
            return redirect("user_invitations")
    
    return redirect("user_invitations")

3. Add URLs for the new views

# Add to web/urls.py
path("groups/<int:group_id>/invite/", views.invite_to_study_group, name="invite_to_study_group"),
path("invitations/", views.user_invitations, name="user_invitations"),
path("invitations/<int:invite_id>/respond/", views.respond_to_invitation, name="respond_to_invitation"),

4. Create a template for viewing invitations

<!-- Create web/templates/web/study/invitations.html -->
{% extends "base.html" %}

{% block title %}
  Study Group Invitations
{% endblock title %}
{% block content %}
  <div class="container mx-auto px-4 py-8">
    <div class="max-w-4xl mx-auto">
      <div class="mb-8">
        <h1 class="text-3xl font-bold mb-4">Study Group Invitations</h1>
        <p class="text-gray-600 dark:text-gray-300">Manage your study group invitations</p>
      </div>

      <div class="bg-white dark:bg-gray-800 rounded-lg shadow">
        <div class="p-6">
          {% if invitations %}
            <div class="space-y-6">
              {% for invite in invitations %}
                <div class="border dark:border-gray-700 rounded-lg p-4">
                  <div class="flex justify-between items-start">
                    <div>
                      <h3 class="text-lg font-medium">{{ invite.group.name }}</h3>
                      <p class="text-gray-600 dark:text-gray-400 text-sm mt-1">{{ invite.group.description }}</p>
                      <div class="mt-2 flex items-center space-x-4 text-sm">
                        <span class="text-gray-500 dark:text-gray-400">
                          <i class="fas fa-user mr-1"></i> Invited by {{ invite.sender.username }}
                        </span>
                        <span class="text-gray-500 dark:text-gray-400">
                          <i class="fas fa-clock mr-1"></i> {{ invite.created_at|timesince }} ago
                        </span>
                      </div>
                    </div>
                    <div class="flex space-x-2">
                      <form method="post" action="{% url 'respond_to_invitation' invite.id %}">
                        {% csrf_token %}
                        <input type="hidden" name="response" value="accept" />
                        <button type="submit"
                                class="bg-teal-600 hover:bg-teal-700 text-white px-3 py-1 rounded focus:outline-none">
                          Accept
                        </button>
                      </form>
                      <form method="post" action="{% url 'respond_to_invitation' invite.id %}">
                        {% csrf_token %}
                        <input type="hidden" name="response" value="decline" />
                        <button type="submit"
                                class="bg-red-600 hover:bg-red-700 text-white px-3 py-1 rounded focus:outline-none">
                          Decline
                        </button>
                      </form>
                    </div>
                  </div>
                </div>
              {% endfor %}
            </div>
          {% else %}
            <p class="text-gray-500 dark:text-gray-400">You don't have any pending invitations.</p>
          {% endif %}
        </div>
      </div>
    </div>
  </div>
{% endblock content %}

5. Update the group detail template to include invitation UI

<!-- Add this section to web/templates/web/study/group_detail.html -->
<!-- Place it after the member list section -->

{% if request.user in group.members.all %}
  <div class="mt-6">
    <div class="border border-gray-200 dark:border-gray-700 rounded-lg">
      <div class="border-b border-gray-200 dark:border-gray-700 p-4">
        <h2 class="text-lg font-semibold flex items-center">
          <i class="fa-solid fa-user-plus text-teal-600 dark:text-teal-400 mr-2"></i>
          Invite Friends
        </h2>
      </div>
      <div class="p-4">
        <form method="post" action="{% url 'invite_to_study_group' group.id %}">
          {% csrf_token %}
          <div class="flex space-x-2">
            <input type="text"
                   class="flex-1 border border-gray-300 dark:border-gray-600 rounded p-2 focus:outline-none focus:ring-2 focus:ring-teal-300 dark:focus:ring-teal-800 bg-white dark:bg-gray-800"
                   name="email_or_username"
                   placeholder="Enter email or username"
                   required />
            <button type="submit"
                    class="bg-teal-600 hover:bg-teal-700 text-white font-medium px-4 py-2 rounded focus:outline-none focus:ring-2 focus:ring-teal-500 focus:ring-offset-2 dark:focus:ring-offset-gray-800">
              Send Invite
            </button>
          </div>
          <p class="mt-2 text-sm text-gray-500 dark:text-gray-400">
            Invite a friend to join this study group by email or username
          </p>
        </form>
      </div>
    </div>
  </div>
{% endif %}

6. Add a notification bell indicator for invitations

<!-- Add this to your base template where notifications are shown -->
<a href="{% url 'user_invitations' %}" class="relative">
  <i class="fas fa-bell"></i>
  {% if user.received_group_invites.filter(status='pending').exists %}
    <span class="absolute -top-1 -right-1 h-4 w-4 rounded-full bg-red-600 flex items-center justify-center text-white text-xs">
      {{ user.received_group_invites.filter(status='pending').count }}
    </span>
  {% endif %}
</a>

These changes enable users to:

1. Create study groups (existing functionality)
2. Invite friends or other users to their study groups
3. Receive and respond to study group invitations
4. Get notifications when they're invited to a group

Let me know if you need any adjustments or additional features!

🐰

[10done]

/assign

[github-actions]

Hey @10done! You're now assigned to this issue. Please finish your PR within 1 day.

[10done]

@coderabbitai Has this feature already been implemented in the repository?

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Check if the StudyGroupInvite model exists in models.py
echo "Checking for StudyGroupInvite model..."
grep -A 15 "class StudyGroupInvite" web/models.py || echo "StudyGroupInvite model not found"

# Check if invitation views exist in views.py
echo -e "\nChecking for invitation views..."
grep -E "def (invite_to_study_group|user_invitations|respond_to_invitation)" web/views.py || echo "Invitation views not found"

# Check if invitation templates exist
echo -e "\nChecking for invitation templates..."
find web/templates -name "invitations.html" || echo "Invitations template not found"

# Check if URL patterns for invitations exist
echo -e "\nChecking for invitation URL patterns..."
grep -E "(invite_to_study_group|user_invitations|respond_to_invitation)" web/urls.py || echo "Invitation URL patterns not found"

# Check if basic study group functionality exists
echo -e "\nChecking for basic study group functionality..."
grep -A 10 "class StudyGroup" web/models.py || echo "StudyGroup model not found"
grep -E "def study_group" web/views.py || echo "Study group views not found"

Length of output: 1706

---

@10done No, the study group invitation feature has not been implemented in the repository yet. The basic study group functionality exists (the StudyGroup model and views for displaying groups), but all the invitation-related components are missing:

1. There is no StudyGroupInvite model in models.py
2. The invitation-related views (invite_to_study_group, user_invitations, respond_to_invitation) don't exist
3. There's no invitations.html template
4. No invitation URL patterns are defined in urls.py

The code I provided in my previous response would be a complete implementation of this new feature, building on top of the existing study group functionality.