website/views/issue.py (2)

910-928: Well-implemented profanity check for bug reports.

The implementation effectively:

1. Extracts text from both description fields
2. Combines them for a comprehensive check
3. Creates an enforcement record when profanity is detected
4. Prevents form submission with an appropriate error message

This is a good security measure to prevent inappropriate content in bug reports.

Consider adding a small refactor to sanitize or normalize the text before checking for profanity:

 # Combine fields to check
-text_to_check = f"{description} {markdown_description}"
+text_to_check = f"{description} {markdown_description}".strip()

This would handle edge cases where whitespace might affect the profanity check.

---

929-929: Incomplete code comment.

There appears to be an incomplete or unnecessary comment starting with "# Pr" that doesn't provide any useful information.

Consider removing this incomplete comment or completing it with meaningful information:

-# Pr
+# Proceed with normal form validation

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

website/views/issue.py (2)

926-928: Consider improving the error message for better user experience.

The current error message "Have a nice day." doesn't inform users about why their submission was rejected. A more informative message would improve user experience and reduce confusion.

-            messages.error(self.request, "Have a nice day.")
+            messages.error(self.request, "Your submission contains inappropriate language. Please revise your content and try again.")

---

910-928: Consider enhancing the profanity filter implementation for better usability.

The current implementation blocks submissions entirely when profanity is detected. Consider these enhancements to improve user experience:

1. Highlight problematic terms instead of rejecting outright
2. Add configuration options for sensitivity levels
3. Create an allowlist for false positives
4. Track repeat offenders with escalating responses

A more robust implementation could use a configuration file to control sensitivity and maintain allowlists:

# Example configuration-based approach
from django.conf import settings

# Get configuration from settings
PROFANITY_SETTINGS = getattr(settings, 'PROFANITY_SETTINGS', {
    'censored_words': [],     # Additional words to censor
    'allowed_words': [],      # Words to exclude from censoring
    'action_level': 'block',  # Options: 'warn', 'highlight', 'block'
    'max_warnings': 3,        # Number of warnings before blocking
})

# Configure profanity filter
profanity.load_censor_words(whitelist=PROFANITY_SETTINGS['allowed_words'])
for word in PROFANITY_SETTINGS['censored_words']:
    profanity.add_censor_word(word)

# Later in the code
if profanity.contains_profanity(text_to_check):
    if PROFANITY_SETTINGS['action_level'] == 'block':
        # Current implementation
    elif PROFANITY_SETTINGS['action_level'] == 'highlight':
        # Return with highlighted text
        censored_text = profanity.censor(text_to_check)
        # Show user the censored text and allow editing
    elif PROFANITY_SETTINGS['action_level'] == 'warn':
        # Track warnings for this user
        # Block if exceeded max_warnings

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

website/views/issue.py (1)

910-928: 🛠️ Refactor suggestion

Add unit tests for the profanity checking functionality.

This important content moderation feature lacks test coverage. Consider adding tests to verify profanity detection works as expected with various inputs including edge cases.

Here's a suggested structure for tests:

# In tests.py or a dedicated test file
from django.test import TestCase, RequestFactory
from django.contrib.messages.storage.fallback import FallbackStorage
from django.contrib.auth.models import User
from website.models import Blocked
from website.views.issue import IssueCreate
from unittest.mock import patch

class ProfanityCheckTest(TestCase):
    def setUp(self):
        self.factory = RequestFactory()
        self.user = User.objects.create_user(username='testuser', email='[email protected]', password='testpass')
        
    def test_profanity_detection_blocks_submission(self):
        # Create a request with profanity in the description
        request = self.factory.post('/report/', {
            'description': 'This contains a bad word like sh*t',
            'markdown_description': 'More details',
            # Add other required form fields
        })
        request.user = self.user
        request.META['HTTP_USER_AGENT'] = 'Test User Agent'
        
        # Set up messages framework
        setattr(request, 'session', 'session')
        messages = FallbackStorage(request)
        setattr(request, '_messages', messages)
        
        # Create the view and call form_valid
        view = IssueCreate()
        view.request = request
        
        # Mock the form with cleaned_data
        form = mock.MagicMock()
        form.cleaned_data = {
            'description': 'This contains a bad word like sh*t',
            'markdown_description': 'More details',
        }
        
        # Call form_valid and check the result
        response = view.form_valid(form)
        
        # Verify that a Blocked entry was created
        self.assertEqual(Blocked.objects.count(), 1)
        blocked = Blocked.objects.first()
        self.assertEqual(blocked.reason_for_block, 'Inappropriate language in bug report')
        
        # Verify the user was redirected
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, '/')

website/views/issue.py (3)

926-927: Consider providing a more informative error message.

The generic message "Have a nice day" doesn't inform users why their submission was blocked. A more descriptive message would help users understand the issue and modify their submission accordingly.

-            messages.error(self.request, "Have a nice day.")
+            messages.error(self.request, "Your submission contains inappropriate language. Please revise your content and try again.")

---

910-928: Consider enhancing user experience with warning instead of blocking.

Currently, the implementation blocks submissions completely when profanity is detected. Consider enhancing the user experience by highlighting the inappropriate content and allowing users to edit their submission instead of forcing them to start over.

Example implementation:

     # Check for profanity
     if profanity.contains_profanity(text_to_check):
+        # Log the attempt without blocking
         Blocked.objects.create(
             address=reporter_ip,
             reason_for_block="Inappropriate language in bug report",
             user_agent_string=self.request.META.get("HTTP_USER_AGENT", ""),
             count=1,
         )

-        # Prevent form submission
-        messages.error(self.request, "Have a nice day.")
-        return HttpResponseRedirect("/")
+        # Instead of blocking, warn and return to form
+        messages.warning(self.request, "Your submission contains inappropriate language. Please revise and submit again.")
+        return render(self.request, "report.html", {
+            "form": form,
+            "captcha_form": CaptchaForm(self.request.POST),
+            "has_profanity": True,
+            "submitted_data": form.cleaned_data
+        })

---

910-928: Consider adding configurability for profanity checking.

The current implementation uses default settings for profanity detection. Consider adding configuration options to:

1. Control the sensitivity level
2. Create an allowlist for false positives
3. Allow admin toggling of the feature

This could be implemented using Django settings or a dedicated configuration model:

# In settings.py
PROFANITY_CHECK_ENABLED = True
PROFANITY_SENSITIVITY = 0.8  # 0-1 scale
PROFANITY_ALLOWLIST = ['spam', 'analysis']  # Words that might trigger false positives

# Then in the view
if settings.PROFANITY_CHECK_ENABLED:
    # Configure profanity filter
    profanity.load_censor_words()
    for word in settings.PROFANITY_ALLOWLIST:
        profanity.whitelist_words([word])
    
    # Then check as normal
    if profanity.contains_profanity(text_to_check):
        # Handle profanity...

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro