feat: AI integratoin for bacon scores with a fallback mechanism if API calls are not working (#4398)

* organisation UI changed

* profile integrated

* added UI for bacon in issues and bug

* integrated with reporting Ips

* precommit fixes

* fix recurring bug

* ai integrated

* fix: logging removed

* linting fixed

---------

Co-authored-by: DonnieBLT <[email protected]>

Author: krrish-sehgal

website/feed_signals.py

@@ -18,6 +18,30 @@
     UserBadge,
     UserProfile,
 )
+from .utils import analyze_contribution
+
+# Default BACON rewards for different contribution types
+DEFAULT_BACON_REWARDS = {
+    "Issue": 5,
+    "Post": 10,
+    "Hunt": 15,
+    "IpReport": 3,
+    "Organization": 10,
+    "ForumPost": 2,
+    "Bid": 2,
+}
+
+
+def get_default_bacon_reward(instance, action_type):
+    """Get the default BACON reward for a given instance type"""
+    model_name = instance._meta.model_name.capitalize()
+    base_reward = DEFAULT_BACON_REWARDS.get(model_name, 1)
+
+    # Add bonus for security-related content if applicable
+    if hasattr(instance, "is_security") and getattr(instance, "is_security", False):
+        base_reward += 3
+
+    return base_reward
 
 
 def get_default_user():
@@ -62,37 +86,70 @@ def create_activity(instance, action_type):
     )
 
 
-def giveBacon(user, amt=1):
-    # Check if the user already has a token record
+def giveBacon(user, instance=None, action_type=None, amt=None):
+    """
+    Award BACON tokens to a user based on their contribution.
+    If amt is provided, use that amount directly.
+    Otherwise, analyze the contribution using AI to determine the amount.
+    Falls back to default rewards if AI analysis fails.
+    """
     if user is None or user.is_authenticated is False:
         return
-    token_earning, created = BaconEarning.objects.get_or_create(user=user)
 
-    if created:
-        token_earning.tokens_earned = amt  # Reward 10 tokens for completing the action (adjust as needed)
-    else:
-        token_earning.tokens_earned += amt  # Add 10 tokens if the user already exists in the system
+    token_earning, created = BaconEarning.objects.get_or_create(user=user)
 
-    token_earning.save()  # Save the updated record
+    try:
+        # If amount is specified, use it
+        if amt is not None:
+            reward_amount = amt
+        # Otherwise analyze the contribution if we have an instance
+        elif instance is not None and action_type is not None:
+            try:
+                reward_amount = analyze_contribution(instance, action_type)
+            except Exception as e:
+                # Fallback to default reward system
+                reward_amount = get_default_bacon_reward(instance, action_type)
+        else:
+            reward_amount = 1  # Default minimum reward
+
+        # Ensure reward amount is within valid range (1-50)
+        reward_amount = max(1, min(50, int(reward_amount)))
+
+        if created:
+            token_earning.tokens_earned = reward_amount
+        else:
+            token_earning.tokens_earned += reward_amount
+
+        token_earning.save()
+        return reward_amount
+
+    except Exception as e:
+        # If anything fails, ensure at least minimum reward is given
+        if created:
+            token_earning.tokens_earned = 1
+        else:
+            token_earning.tokens_earned += 1
+        token_earning.save()
+        return 1
 
 
 @receiver(post_save)
 def handle_post_save(sender, instance, created, **kwargs):
     """Generic handler for post_save signal."""
     if sender == IpReport and created:  # Track first IP report
         assign_first_action_badge(instance.user, "First IP Reported")
-        giveBacon(instance.user)
+        giveBacon(instance.user, instance=instance, action_type="created")
         create_activity(instance, "created")
 
     elif sender == Post and created:  # Track first blog post
         assign_first_action_badge(instance.author, "First Blog Posted")
         create_activity(instance, "created")
-        giveBacon(instance.author, 5)  # Reward for posting a blog
+        giveBacon(instance.author, instance=instance, action_type="created")
 
     elif sender == Issue and created:  # Track first bug report
         assign_first_action_badge(instance.user, "First Bug Reported")
         create_activity(instance, "created")
-        giveBacon(instance.user, 5)  # Reward for reporting a bug
+        giveBacon(instance.user, instance=instance, action_type="created")
 
     elif sender == Hunt and created:  # Track first bug bounty
         # Attempt to get the user from Domain managers or Organization
@@ -108,17 +165,17 @@ def handle_post_save(sender, instance, created, **kwargs):
         if user:
             assign_first_action_badge(user, "First Bug Bounty")
             create_activity(instance, "created")
-            giveBacon(user, 5)  # Reward for creating a bug bounty
+            giveBacon(user, instance=instance, action_type="created")
 
     elif sender == ForumPost and created:  # Track first forum post
         assign_first_action_badge(instance.user, "First Forum Post")
         create_activity(instance, "created")
-        giveBacon(instance.user, 2)  # Reward for posting in forum
+        giveBacon(instance.user, instance=instance, action_type="created")
 
     elif sender == Bid and created:  # Track first bid placed
         assign_first_action_badge(instance.user, "First Bid Placed")
         create_activity(instance, "placed")
-        giveBacon(instance.user, 2)  # Reward for placing a bid
+        giveBacon(instance.user, instance=instance, action_type="placed")
 
     elif sender is User and created:  # Handle user sign-up
         Activity.objects.create(
@@ -158,9 +215,9 @@ def update_user_streak(sender, instance, created, **kwargs):
 def handle_organization_creation(sender, instance, created, **kwargs):
     """Give bacon to user when they create an organization"""
     if created and instance.admin:
-        # Give 10 bacon tokens for creating an organization
-        giveBacon(instance.admin, 10)
-        # Create an activity for the organization creation
+        # Create an activity first so it's included in the AI analysis
         create_activity(instance, "created")
+        # Give bacon tokens using AI analysis or fallback to default (10)
+        giveBacon(instance.admin, instance=instance, action_type="created")
         # Give first organization badge
         assign_first_action_badge(instance.admin, "First Organization Created")

website/templates/gsoc.html

@@ -678,7 +678,9 @@ <h3 class="text-xl font-semibold text-gray-900">Sudhir Palavalasa</h3>
                                     <h3 class="text-xl font-semibold text-gray-900">Ahmed ElSheikh</h3>
                                 </div>
                             </div>
-                            <p class="text-gray-700">As a cybersecurity analyst and AI security engineer, I bring a strong background in threat detection, secure system design, and AI model protection. For GSoC 2025, I'm mentoring students on cutting-edge AI fingerprinting techniques and secure AI integrations in web applications. My goal is to empower contributors to build real-world, secure systems while learning to navigate the intersection of AI and cybersecurity.</p>
+                            <p class="text-gray-700">
+                                As a cybersecurity analyst and AI security engineer, I bring a strong background in threat detection, secure system design, and AI model protection. For GSoC 2025, I'm mentoring students on cutting-edge AI fingerprinting techniques and secure AI integrations in web applications. My goal is to empower contributors to build real-world, secure systems while learning to navigate the intersection of AI and cybersecurity.
+                            </p>
                         </div>
                     </div>
                 </div>

website/utils.py

@@ -1017,3 +1017,91 @@ def check_security_txt(domain_url):
 
     # If we reach here, no security.txt was found
     return False
+
+
+def analyze_contribution(instance, action_type):
+    """
+    Analyze a contribution using OpenAI to determine BACON token reward.
+    Returns a score between 1-50 based on complexity, impact, and quality.
+    """
+    try:
+        # Extract relevant data from the instance
+        model_name = instance._meta.model_name
+        title = getattr(instance, "title", None) or getattr(instance, "description", None)
+        description = getattr(instance, "content", None) or getattr(instance, "body", None)
+        is_security = getattr(instance, "is_security", False)
+
+        # Construct the analysis prompt
+        prompt = f"""
+        Analyze this contribution and assign a BACON token reward score between 1 and 50.
+        
+        Contribution Details:
+        - Type: {model_name}
+        - Action: {action_type}
+        - Title: {title}
+        - Description: {description}
+        - Security Related: {is_security}
+
+        Scoring Guidelines:
+        - Basic contributions (simple issues, comments): 1-5 BACON
+        - Standard contributions (well-documented issues, blog posts): 5-15 BACON
+        - Valuable contributions (detailed bug reports, tutorials): 15-25 BACON
+        - High-impact contributions (security vulnerabilities, major features): 25-50 BACON
+
+        Evaluation Criteria:
+        1. Technical complexity
+        2. Documentation quality
+        3. Security impact
+        4. Community benefit
+        5. Overall effort
+
+        Return only a number between 1 and 50.
+        """
+
+        # Get response from OpenAI
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": "You are evaluating contributions to determine BACON token rewards."},
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.3,
+            max_tokens=10,
+        )
+
+        # Extract and validate the score
+        try:
+            score = int(float(response.choices[0].message.content.strip()))
+            # Ensure score is within bounds
+            score = max(1, min(50, score))
+            return score
+        except (ValueError, AttributeError):
+            # Default scores if parsing fails
+            return get_default_bacon_score(model_name, is_security)
+
+    except Exception as e:
+        logging.error(f"Error analyzing contribution for BACON score: {str(e)}")
+        return get_default_bacon_score(model_name, is_security)
+
+
+def get_default_bacon_score(model_name, is_security=False):
+    """
+    Get default BACON score based on contribution type.
+    """
+    base_scores = {
+        "issue": 5,
+        "post": 10,
+        "hunt": 15,
+        "ipreport": 3,
+        "organization": 10,
+        "forumpost": 2,
+    }
+
+    # Get base score or default to 5
+    score = base_scores.get(model_name.lower(), 5)
+
+    # Add bonus for security-related content
+    if is_security:
+        score += 3
+
+    return score