Merge pull request #44 from devondragon/issue-43-Add-Filter-for-Spring-Security-Form-Login-Support

Issue 43 add filter for spring security form login support

Author: devondragon

README.md

@@ -138,16 +138,16 @@ public class LoginController {
 
     @Autowired
     private TurnstileValidationService turnstileValidationService;
-    
+
     @Autowired
     private UserService userService;
-    
+
     @PostMapping("/login")
-    public String login(Model model, 
+    public String login(Model model,
                       @RequestParam String email,
                       @RequestParam(name = "cf-turnstile-response", required = true) String turnstileResponse,
                       HttpServletRequest request) {
-                      
+
         // Get the client IP address (recommended for security)
         String clientIpAddress = turnstileValidationService.getClientIpAddress(request);
 
@@ -266,6 +266,55 @@ Spring Cloudflare Turnstile uses Spring Boot's auto-configuration to seamlessly
 
 7. **DTO Layer**: Response objects map directly to Cloudflare's API responses.
 
+## Optional: Configuring Turnstile Captcha Filter with Spring Security
+
+This project provides an optional helper component, **TurnstileCaptchaFilter**, which can be used to add Turnstile captcha validation to your Spring Security Form Lgin flow.
+
+### Configuration
+
+Configure the following properties in your `application.properties` or `application.yml`:
+
+```properties
+ds.cf.turnstile.login.submissionPath=/login
+ds.cf.turnstile.login.redirectUrl=/login?error=captcha
+ds.cf.turnstile.token.parameterName=cf-turnstile-response
+```
+
+### Integration with Spring Security
+
+To use the filter with form login, add it to your security configuration before the default authentication filter:
+
+```java
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http,
+                                             TurnstileCaptchaFilter turnstileCaptchaFilter) throws Exception {
+        http
+            // Add the Turnstile captcha filter before the default authentication filter
+            .addFilterBefore(turnstileCaptchaFilter, UsernamePasswordAuthenticationFilter.class)
+            .formLogin(form -> form
+                .loginPage("/login")
+                .defaultSuccessUrl("/home")
+                .failureUrl("/login?error") // You might handle errors differently
+            )
+            .authorizeHttpRequests(auth -> auth
+                .anyRequest().authenticated()
+            );
+        return http.build();
+    }
+}
+```
+
+### Notes
+
+- The filter checks if the request's servlet path matches the configured login submission path and that the HTTP method is POST.
+- It validates the captcha token (expected to be sent under the configured parameter name) using the TurnstileValidationService.
+- On a successful captcha validation, the request continues through the filter chain. Otherwise, it logs a warning and redirects to the login page.
+- This component is completely optional; if you do not require captcha validation for your login flow, do not enable or configure this filter.
+
 ## Contributing
 
 Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to this project.

generate_changelog.py

@@ -3,52 +3,186 @@
 import subprocess
 from openai import OpenAI
 from datetime import date
+import re
+# tempfile no longer needed
 
-def get_git_commits():
+def get_git_commits_with_diffs():
     # Get the last tag
-    last_tag = subprocess.check_output(
-        ["git", "describe", "--tags", "--abbrev=0"], text=True
+    try:
+        last_tag = subprocess.check_output(
+            ["git", "describe", "--tags", "--abbrev=0"], text=True
+        ).strip()
+    except subprocess.CalledProcessError:
+        # If no tags exist, use the first commit
+        last_tag = subprocess.check_output(
+            ["git", "rev-list", "--max-parents=0", "HEAD"], text=True
+        ).strip()
+        print("No tags found. Using the first commit as reference.")
+
+    # Get commit hashes and messages since the last tag
+    commit_info = subprocess.check_output(
+        ["git", "log", f"{last_tag}..HEAD", "--pretty=format:%H|%s"], text=True
     ).strip()
 
-    # Get commit messages since the last tag
-    commits = subprocess.check_output(
-        ["git", "log", f"{last_tag}..HEAD", "--pretty=format:%s"], text=True
-    ).strip()
+    if not commit_info:
+        return last_tag, []
+
+    commits_with_diffs = []
+    for line in commit_info.split("\n"):
+        if not line:
+            continue
+
+        commit_hash, commit_message = line.split("|", 1)
+
+        # Get the diff for this commit
+        diff = subprocess.check_output(
+            ["git", "show", "--stat", "--patch", commit_hash], text=True
+        )
+
+        # Extract file changes
+        files_changed = subprocess.check_output(
+            ["git", "show", "--name-status", commit_hash], text=True
+        ).strip()
+
+        commits_with_diffs.append({
+            "hash": commit_hash,
+            "message": commit_message,
+            "diff": diff,
+            "files_changed": files_changed
+        })
+
+    return last_tag, commits_with_diffs
+
+def categorize_commits(commits_with_diffs):
+    """Pre-categorize commits based on conventional commit prefixes"""
+    categories = {
+        "features": [],
+        "fixes": [],
+        "breaking_changes": [],
+        "refactorings": [],
+        "docs": [],
+        "tests": [],
+        "other": []
+    }
+
+    for commit in commits_with_diffs:
+        message = commit["message"].lower()
+
+        # Check for breaking changes first
+        if "breaking change" in message or "!" in message.split(":", 1)[0]:
+            categories["breaking_changes"].append(commit)
+        # Then check for common prefixes
+        elif message.startswith(("feat", "feature")):
+            categories["features"].append(commit)
+        elif message.startswith(("fix", "bugfix", "bug")):
+            categories["fixes"].append(commit)
+        elif message.startswith("refactor"):
+            categories["refactorings"].append(commit)
+        elif message.startswith(("doc", "docs")):
+            categories["docs"].append(commit)
+        elif message.startswith(("test", "tests")):
+            categories["tests"].append(commit)
+        else:
+            # Attempt to categorize based on the diff
+            if any(term in commit["diff"].lower() for term in ["fix", "bug", "issue", "error", "crash"]):
+                categories["fixes"].append(commit)
+            elif any(term in commit["diff"].lower() for term in ["feat", "feature", "add", "new", "implement"]):
+                categories["features"].append(commit)
+            else:
+                categories["other"].append(commit)
+
+    return categories
+
+def generate_changelog(commits_with_diffs, categorized_commits):
+    if not commits_with_diffs:
+        return "No commits to include in the changelog."
 
-    return last_tag, commits.split("\n")
+    # Prepare the detailed diff information
+    diff_content = "# Git Commit Information for Changelog Generation\n\n"
 
-def generate_changelog(commits):
-    if not commits:
-        return "No commits to include in the changelog."
+    # Add categorized commit information
+    for category, commits in categorized_commits.items():
+        if commits:
+            diff_content += f"## {category.replace('_', ' ').title()}\n"
+            for commit in commits:
+                diff_content += f"### Commit: {commit['hash'][:8]} - {commit['message']}\n"
+
+                # Add file changes summary
+                diff_content += "#### Files Changed:\n"
+                diff_content += f"```\n{commit['files_changed']}\n```\n"
+
+                # Add a truncated diff only if it's very long (over 500 lines)
+                diff_lines = commit['diff'].split('\n')
+                if len(diff_lines) > 500:
+                    truncated_diff = '\n'.join(diff_lines[:500])
+                    truncated_diff += f"\n... (diff truncated, showing first 500 of {len(diff_lines)} lines)"
+                else:
+                    truncated_diff = commit['diff']
 
+                diff_content += "#### Diff Preview:\n"
+                diff_content += f"```diff\n{truncated_diff}\n```\n\n"
+
+    # Build the prompt with categorized information and diff data
     prompt = f"""
-    You are a helpful assistant tasked with creating a changelog. Based on these Git commit messages, generate a clear, human-readable changelog:
+You are a skilled software developer tasked with creating a detailed changelog.
+I have provided you with git commit information including:
+1. Commit messages
+2. File changes
+3. Code diffs
+
+Please generate a clear, comprehensive changelog based on this information.
+The commits have been pre-categorized, but please use the actual code changes to:
+- Improve category assignments if needed
+- Add more specific details about what changed in each commit
+- Extract key implementation details from the diffs
+- Identify significant changes that aren't clear from just the commit messages
+
+Here is the detailed commit information:
+
+{diff_content}
+
+Format the changelog in Markdown as follows:
+### Features
+- Detailed feature descriptions here, with substantive information from the diffs
 
-    Commit messages:
-    {commits}
+### Fixes
+- Detailed bug fix descriptions here, with substantive information from the diffs
 
-    Format the changelog as follows:
-    ### Features
-    - List features here
+### Breaking Changes
+- Detailed descriptions of breaking changes here (if any), with clear explanations of what changed
 
-    ### Fixes
-    - List fixes here
+### Refactoring
+- Important code refactoring changes (if any)
 
-    ### Breaking Changes
-    - List breaking changes here (if any)
-    """
+### Documentation
+- Documentation updates (if any)
+
+### Testing
+- Test-related changes (if any)
+
+### Other Changes
+- Any other significant changes
+
+Important: Focus on providing value to humans reading the changelog. Explain changes in user-centric terms where possible.
+"""
 
     client = OpenAI(
-        api_key=os.environ.get("OPENAI_API_TOKEN"),  # This is the default and can be omitted
+        api_key=os.environ.get("OPENAI_API_TOKEN"),
     )
+
+    # Use GPT-4o (without fallback)
     response = client.chat.completions.create(
-        model="gpt-4",
+        model="gpt-4o",
         messages=[
-            {"role": "system", "content": "You are a helpful assistant for software development."},
+            {"role": "system", "content": "You are a helpful assistant for software development with expertise in analyzing code changes and creating detailed changelogs."},
             {"role": "user", "content": prompt},
         ],
     )
-    return response.choices[0].message.content.strip()
+    changelog = response.choices[0].message.content.strip()
+
+    # No temporary file to clean up anymore
+
+    return changelog
 
 def update_changelog(version, changelog_content):
     changelog_file = "CHANGELOG.md"
@@ -65,13 +199,19 @@ def update_changelog(version, changelog_content):
             f.write(new_entry)
 
 if __name__ == "__main__":
-    last_tag, commits = get_git_commits()
-    if not commits:
+    last_tag, commits_with_diffs = get_git_commits_with_diffs()
+
+    if not commits_with_diffs:
         print("No new commits found.")
-        exit()
+        sys.exit(0)
+
+    print(f"Found {len(commits_with_diffs)} commits since {last_tag}")
 
-    print("Generating changelog...")
-    changelog_content = generate_changelog("\n".join(commits))
+    # Pre-categorize commits for better LLM results
+    categorized_commits = categorize_commits(commits_with_diffs)
+
+    print("Generating detailed changelog...")
+    changelog_content = generate_changelog(commits_with_diffs, categorized_commits)
 
     print("\nGenerated Changelog:")
     print(changelog_content)
@@ -84,5 +224,4 @@ def update_changelog(version, changelog_content):
         new_version = input("Enter the new version (e.g., 1.0.0): ").strip()
 
     update_changelog(new_version, changelog_content)
-
     print(f"Changelog updated for version {new_version}!")

src/main/java/com/digitalsanctuary/cf/turnstile/TurnstileConfiguration.java

@@ -10,23 +10,23 @@
 import com.digitalsanctuary.cf.turnstile.config.TurnstileHealthIndicator;
 import com.digitalsanctuary.cf.turnstile.config.TurnstileMetricsConfig;
 import com.digitalsanctuary.cf.turnstile.config.TurnstileServiceConfig;
-
+import com.digitalsanctuary.cf.turnstile.filter.TurnstileCaptchaFilter;
 import io.micrometer.core.instrument.MeterRegistry;
 import jakarta.annotation.PostConstruct;
 import lombok.extern.slf4j.Slf4j;
 
 /**
  * Main auto-configuration class for the Spring Cloudflare Turnstile integration.
  * <p>
- * This class serves as the entry point for Spring Boot's auto-configuration mechanism to
- * automatically set up Cloudflare Turnstile integration when the library is included in a project.
- * It imports the necessary configuration components such as property management, service configuration,
- * and metrics/monitoring configuration.
+ * This class serves as the entry point for Spring Boot's auto-configuration mechanism to automatically set up Cloudflare Turnstile integration when
+ * the library is included in a project. It imports the necessary configuration components such as property management, service configuration, and
+ * metrics/monitoring configuration.
  * </p>
  * <p>
- * To use this auto-configuration, include this library in your Spring Boot project and configure
- * the required properties in your application.yml or application.properties file:
+ * To use this auto-configuration, include this library in your Spring Boot project and configure the required properties in your application.yml or
+ * application.properties file:
  * </p>
+ * 
  * <pre>
  * ds:
  *   cf:
@@ -40,10 +40,10 @@
  *         error-threshold: 10
  * </pre>
  * <p>
- * The {@link #onStartup()} method is annotated with {@link jakarta.annotation.PostConstruct} and is executed 
- * after the bean initialization to log a confirmation message that the Cloudflare Turnstile Service has been loaded.
+ * The {@link #onStartup()} method is annotated with {@link jakarta.annotation.PostConstruct} and is executed after the bean initialization to log a
+ * confirmation message that the Cloudflare Turnstile Service has been loaded.
  * </p>
- * 
+ *
  * @see com.digitalsanctuary.cf.turnstile.config.TurnstileConfigProperties
  * @see com.digitalsanctuary.cf.turnstile.config.TurnstileServiceConfig
  * @see com.digitalsanctuary.cf.turnstile.service.TurnstileValidationService
@@ -53,15 +53,11 @@
 @Slf4j
 @Configuration
 @AutoConfiguration
-@Import({
-    TurnstileServiceConfig.class, 
-    TurnstileConfigProperties.class
-})
+@Import({TurnstileServiceConfig.class, TurnstileConfigProperties.class, TurnstileCaptchaFilter.class})
 public class TurnstileConfiguration {
 
     /**
-     * Metrics configuration for Turnstile.
-     * Only imported if MeterRegistry is available on the classpath.
+     * Metrics configuration for Turnstile. Only imported if MeterRegistry is available on the classpath.
      */
     @Configuration
     @ConditionalOnClass(MeterRegistry.class)
@@ -70,8 +66,7 @@ static class TurnstileMetricsConfiguration {
     }
 
     /**
-     * Health indicator configuration for Turnstile.
-     * Only imported if Spring Actuator health is enabled.
+     * Health indicator configuration for Turnstile. Only imported if Spring Actuator health is enabled.
      */
     @Configuration
     @ConditionalOnEnabledHealthIndicator("turnstile")