feature/Implementation of management command.

backend/Makefile

@@ -108,6 +108,8 @@ shell-db:
 
 sync-data: \
 	update-data \
+	owasp-update-project-health-metrics \
+	owasp-update-project-health-scores \
 	enrich-data \
 	index-data
 
@@ -133,6 +135,7 @@ update-data: \
 	github-update-related-organizations \
 	github-update-users \
 	owasp-aggregate-projects \
+	owasp-sync-official-project-levels \
 	owasp-update-events \
 	owasp-sync-posts \
 	owasp-update-sponsors \

backend/apps/owasp/Makefile

@@ -33,6 +33,10 @@ owasp-update-project-health-metrics:
 	@echo "Updating OWASP project health metrics"
 	@CMD="python manage.py owasp_update_project_health_metrics" $(MAKE) exec-backend-command
 
+owasp-sync-official-project-levels:
+	@echo "Syncing official OWASP project levels"
+	@CMD="python manage.py owasp_update_project_health_metrics --sync-official-levels-only" $(MAKE) exec-backend-command
+
 owasp-update-project-health-requirements:
 	@echo "Updating OWASP project health requirements"
 	@CMD="python manage.py owasp_update_project_health_requirements" $(MAKE) exec-backend-command

backend/apps/owasp/management/commands/owasp_detect_project_level_compliance.py

@@ -0,0 +1,112 @@
+"""A command to detect and report project level compliance status."""
+
+import logging
+
+from django.core.management.base import BaseCommand
+
+from apps.owasp.models.project import Project
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """Command to detect and report project level compliance status.
+
+    This is a reporting command only - it does not sync or update any data.
+    For data synchronization, use the main data pipeline: make sync-data
+
+    Architecture:
+    - Part 1: Official level syncing happens during 'make update-data'
+    - Part 2: Health scoring with compliance penalties happens during 'make sync-data'
+    - This command: Reporting and analysis only
+    """
+
+    help = "Detect and report projects with non-compliant level assignments"
+
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            "--verbose",
+            action="store_true",
+            help="Enable verbose output showing all projects",
+        )
+
+    def handle(self, *args, **options):
+        """Execute compliance detection and reporting."""
+        verbose = options["verbose"]
+
+        self.stdout.write("Analyzing project level compliance status...")
+
+        # Get all active projects
+        active_projects = Project.objects.filter(is_active=True).select_related()
+
+        compliant_projects = []
+        non_compliant_projects = []
+
+        for project in active_projects:
+            if project.is_level_compliant:
+                compliant_projects.append(project)
+                if verbose:
+                    self.stdout.write(f"✓ {project.name}: {project.level} (matches official)")
+            else:
+                non_compliant_projects.append(project)
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"✗ {project.name}: Local={project.level}, "
+                        f"Official={project.project_level_official}"
+                    )
+                )
+
+        # Summary statistics
+        total_projects = len(active_projects)
+        compliant_count = len(compliant_projects)
+        non_compliant_count = len(non_compliant_projects)
+        compliance_rate = (compliant_count / total_projects * 100) if total_projects else 0.0
+
+        self.stdout.write("\n" + "=" * 60)
+        self.stdout.write("PROJECT LEVEL COMPLIANCE SUMMARY")
+        self.stdout.write("=" * 60)
+        self.stdout.write(f"Total active projects: {total_projects}")
+        self.stdout.write(f"Compliant projects: {compliant_count}")
+        self.stdout.write(f"Non-compliant projects: {non_compliant_count}")
+        self.stdout.write(f"Compliance rate: {compliance_rate:.1f}%")
+
+        if non_compliant_count > 0:
+            warning_msg = f"WARNING: Found {non_compliant_count} non-compliant projects"
+            self.stdout.write(f"\n{self.style.WARNING(warning_msg)}")
+            penalty_msg = (
+                "These projects will receive score penalties in the next health score update."
+            )
+            self.stdout.write(penalty_msg)
+        else:
+            self.stdout.write(f"\n{self.style.SUCCESS('✓ All projects are level compliant!')}")
+
+        # Log summary for monitoring
+        logger.info(
+            "Project level compliance analysis completed",
+            extra={
+                "total_projects": total_projects,
+                "compliant_projects": compliant_count,
+                "non_compliant_projects": non_compliant_count,
+                "compliance_rate": f"{compliance_rate:.1f}%",
+            },
+        )
+
+        # Check if official levels are populated
+        from apps.owasp.models.enums.project import ProjectLevel
+
+        default_level = ProjectLevel.OTHER
+        projects_without_official_level = sum(
+            1 for project in active_projects if project.project_level_official == default_level
+        )
+
+        if projects_without_official_level > 0:
+            info_msg = (
+                f"INFO: {projects_without_official_level} projects have default official levels"
+            )
+            self.stdout.write(f"\n{self.style.NOTICE(info_msg)}")
+            sync_msg = (
+                "Run 'make update-data' to sync official levels, "
+                "then 'make sync-data' for scoring."
+            )
+            self.stdout.write(sync_msg)

backend/apps/owasp/management/commands/owasp_update_project_health_metrics.py

@@ -1,15 +1,164 @@
 """A command to update OWASP project health metrics."""
 
+import logging
+
+import requests
 from django.core.management.base import BaseCommand
+from requests.exceptions import RequestException
 
 from apps.owasp.models.project import Project
 from apps.owasp.models.project_health_metrics import ProjectHealthMetrics
 
+logger = logging.getLogger(__name__)
+
+OWASP_PROJECT_LEVELS_URL = (
+    "https://raw.githubusercontent.com/OWASP/owasp.github.io/main/_data/project_levels.json"
+)
+
 
 class Command(BaseCommand):
     help = "Update OWASP project health metrics."
 
+    def add_arguments(self, parser):
+        """Add command line arguments."""
+        parser.add_argument(
+            "--skip-official-levels",
+            action="store_true",
+            help="Skip fetching official project levels from OWASP GitHub repository",
+        )
+        parser.add_argument(
+            "--sync-official-levels-only",
+            action="store_true",
+            help="Only sync official project levels, skip health metrics updates",
+        )
+        parser.add_argument(
+            "--timeout",
+            type=int,
+            default=30,
+            help="HTTP timeout for fetching project levels (default: 30 seconds)",
+        )
+
+    def fetch_official_project_levels(self, timeout: int = 30) -> dict[str, str] | None:
+        """Fetch project levels from OWASP GitHub repository.
+
+        Args:
+            timeout: HTTP request timeout in seconds
+
+        Returns:
+            Dict mapping project names to their official levels, or None if fetch fails
+
+        """
+        try:
+            response = requests.get(
+                OWASP_PROJECT_LEVELS_URL,
+                timeout=timeout,
+                headers={"Accept": "application/json"},
+            )
+            response.raise_for_status()
+            data = response.json()
+            if not isinstance(data, list):
+                logger.exception(
+                    "Invalid project levels data format",
+                    extra={"expected": "list", "got": type(data).__name__},
+                )
+                return None
+
+            # Convert the list to a dict mapping project names to their levels
+            project_levels = {}
+            for entry in data:
+                if not isinstance(entry, dict):
+                    continue
+                project_name = entry.get("name")
+                level = entry.get("level")
+                if (
+                    isinstance(project_name, str)
+                    and isinstance(level, (str, int, float))
+                    and project_name.strip()
+                ):
+                    project_levels[project_name.strip()] = str(level)
+
+        except (RequestException, ValueError) as e:
+            logger.exception(
+                "Failed to fetch project levels",
+                extra={"url": OWASP_PROJECT_LEVELS_URL, "error": str(e)},
+            )
+            return None
+        else:
+            return project_levels
+
+    def update_official_levels(self, official_levels: dict[str, str]) -> int:
+        """Update official levels for projects.
+
+        Args:
+            official_levels: Dict mapping project names to their official levels
+
+        Returns:
+            Number of projects updated
+
+        """
+        updated_count = 0
+        projects_to_update = []
+
+        # Normalize official levels by stripping whitespace and normalizing case
+        normalized_official_levels = {
+            k.strip().lower(): v.strip().lower() for k, v in official_levels.items()
+        }
+
+        for project in Project.objects.filter(is_active=True):
+            normalized_project_name = project.name.strip().lower()
+            if normalized_project_name in normalized_official_levels:
+                official_level = normalized_official_levels[normalized_project_name]
+                # Map string levels to enum values
+                level_mapping = {
+                    "incubator": "incubator",
+                    "lab": "lab",
+                    "production": "production",
+                    "flagship": "flagship",
+                    "2": "incubator",
+                    "3": "lab",
+                    "3.5": "production",
+                    "4": "flagship",
+                }
+                mapped_level = level_mapping.get(official_level, "other")
+
+                if project.project_level_official != mapped_level:
+                    project.project_level_official = mapped_level
+                    projects_to_update.append(project)
+                    updated_count += 1
+
+        if projects_to_update:
+            Project.bulk_save(projects_to_update, fields=["project_level_official"])
+            self.stdout.write(f"Updated official levels for {updated_count} projects")
+        else:
+            self.stdout.write("No official level updates needed")
+
+        return updated_count
+
     def handle(self, *args, **options):
+        skip_official_levels = options["skip_official_levels"]
+        sync_official_levels_only = options["sync_official_levels_only"]
+        timeout = options["timeout"]
+
+        # Part 1: Sync official project levels during project sync
+        if not skip_official_levels:
+            self.stdout.write("Fetching official project levels from OWASP GitHub repository...")
+            official_levels = self.fetch_official_project_levels(timeout=timeout)
+            if official_levels:
+                success_msg = (
+                    f"Successfully fetched {len(official_levels)} official project levels"
+                )
+                self.stdout.write(success_msg)
+                self.update_official_levels(official_levels)
+            else:
+                warning_msg = "Failed to fetch official project levels, continuing without updates"
+                self.stdout.write(self.style.WARNING(warning_msg))
+
+        # If only syncing official levels, stop here (Part 1 only)
+        if sync_official_levels_only:
+            self.stdout.write(self.style.SUCCESS("Official level sync completed."))
+            return
+
+        # Part 2: Update project health metrics (only if not sync-only mode)
         metric_project_field_mapping = {
             "contributors_count": "contributors_count",
             "created_at": "created_at",