Implement Award model with bulk operations

Author: trucodd

backend/Makefile

@@ -109,7 +109,6 @@ shell-db:
 sync-data: \
 	update-data \
 	enrich-data \
-	owasp-update-badges \
 	index-data
 
 test-backend:

backend/apps/owasp/Makefile

@@ -67,7 +67,3 @@ owasp-update-events:
 owasp-update-sponsors:
 	@echo "Getting OWASP sponsors data"
 	@CMD="python manage.py owasp_update_sponsors" $(MAKE) exec-backend-command
-
-owasp-update-badges:
-	@echo "Updating OWASP user badges"
-	@CMD="python manage.py owasp_update_badges" $(MAKE) exec-backend-command

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

@@ -82,43 +82,9 @@ def handle(self, *args, **options):
     def _process_awards_data(self, awards_data: list[dict], *, dry_run: bool = False):
         """Process the awards data from YAML."""
         for item in awards_data:
-            if item.get("type") == "category":
-                self._process_category(item, dry_run=dry_run)
-            elif item.get("type") == "award":
+            if item.get("type") == "award":
                 self._process_award(item, dry_run=dry_run)
 
-    def _process_category(self, category_data: dict, *, dry_run: bool = False):
-        """Process a category definition."""
-        category_name = category_data.get("title", "")
-        description = category_data.get("description", "")
-
-        if not category_name:
-            logger.warning("Skipping category with no title")
-            return
-
-        # Create or update category record
-        if not dry_run:
-            award, created = Award.objects.get_or_create(
-                name=category_name,
-                award_type="category",
-                defaults={
-                    "category": category_name,
-                    "description": description,
-                },
-            )
-
-            if created:
-                self.awards_created += 1
-                logger.debug("Created category: %s", category_name)
-            else:
-                # Update existing category
-                award.description = description
-                award.save(update_fields=["description", "nest_updated_at"])
-                self.awards_updated += 1
-                logger.debug("Updated category: %s", category_name)
-        else:
-            logger.debug("[DRY RUN] Would process category: %s", category_name)
-
     def _process_award(self, award_data: dict, *, dry_run: bool = False):
         """Process an individual award."""
         award_name = award_data.get("title", "")
@@ -130,30 +96,31 @@ def _process_award(self, award_data: dict, *, dry_run: bool = False):
             logger.warning("Skipping incomplete award: %s", award_data)
             return
 
-        # Process each winner
+        # Process each winner using the model's update_data method
         for winner_data in winners:
-            self._process_winner(award_name, category, year, winner_data, dry_run=dry_run)
-
-    def _process_winner(
-        self,
-        award_name: str,
-        category: str,
-        year: int,
-        winner_data: dict,
-        *,
-        dry_run: bool = False,
-    ):
+            # Prepare winner data with award context
+            winner_with_context = {
+                "title": award_name,
+                "category": category,
+                "year": year,
+                "name": winner_data.get("name", ""),
+                "info": winner_data.get("info", ""),
+                "image": winner_data.get("image", ""),
+            }
+
+            self._process_winner(winner_with_context, dry_run=dry_run)
+
+    def _process_winner(self, winner_data: dict, *, dry_run: bool = False):
         """Process an individual award winner."""
         winner_name = winner_data.get("name", "").strip()
-        winner_info = winner_data.get("info", "")
-        winner_image = winner_data.get("image", "")
+        award_name = winner_data.get("title", "")
 
         if not winner_name:
             logger.warning("Skipping winner with no name for award: %s", award_name)
             return
 
         # Try to match winner with existing user
-        matched_user = self._match_user(winner_name, winner_info)
+        matched_user = self._match_user(winner_name, winner_data.get("info", ""))
 
         if matched_user:
             self.users_matched += 1
@@ -164,42 +131,33 @@ def _process_winner(
             logger.warning("Could not match user: %s", winner_name)
 
         if not dry_run:
-            # Create or update award record
-            award, created = Award.objects.get_or_create(
-                name=award_name,
-                category=category,
-                year=year,
-                winner_name=winner_name,
-                defaults={
-                    "award_type": "award",
-                    "description": "",
-                    "winner_info": winner_info,
-                    "winner_image": winner_image,
-                    "user": matched_user,
-                },
-            )
-
-            if created:
+            # Check if award exists before update
+            try:
+                Award.objects.get(
+                    name=award_name,
+                    category=winner_data.get("category", ""),
+                    year=winner_data.get("year"),
+                    winner_name=winner_name,
+                )
+                is_new = False
+            except Award.DoesNotExist:
+                is_new = True
+
+            # Use the model's update_data method
+            award = Award.update_data(winner_data, save=True)
+
+            # Update user association if matched
+            if matched_user and award.user != matched_user:
+                award.user = matched_user
+                award.save(update_fields=["user", "nest_updated_at"])
+
+            # Track creation/update stats
+            if is_new:
                 self.awards_created += 1
                 logger.debug("Created award: %s for %s", award_name, winner_name)
             else:
-                # Update existing award
-                updated_fields = []
-                if award.winner_info != winner_info:
-                    award.winner_info = winner_info
-                    updated_fields.append("winner_info")
-                if award.winner_image != winner_image:
-                    award.winner_image = winner_image
-                    updated_fields.append("winner_image")
-                if award.user != matched_user:
-                    award.user = matched_user
-                    updated_fields.append("user")
-
-                if updated_fields:
-                    updated_fields.append("nest_updated_at")
-                    award.save(update_fields=updated_fields)
-                    self.awards_updated += 1
-                    logger.debug("Updated award: %s for %s", award_name, winner_name)
+                self.awards_updated += 1
+                logger.debug("Updated award: %s for %s", award_name, winner_name)
         else:
             logger.debug("[DRY RUN] Would process winner: %s for %s", winner_name, award_name)
 

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

@@ -4,10 +4,10 @@
 
 from django.db import models
 
-from apps.common.models import TimestampedModel
+from apps.common.models import BulkSaveModel, TimestampedModel
 
 
-class Award(TimestampedModel):
+class Award(BulkSaveModel, TimestampedModel):
     """OWASP Award model.
 
     Represents OWASP awards based on the canonical source at:
@@ -120,63 +120,61 @@ def get_user_waspy_awards(cls, user):
         return cls.objects.filter(user=user, category=cls.Category.WASPY)
 
     @staticmethod
-    def update_data(award_data: dict, *, save: bool = True):
-        """Update award data from YAML structure.
+    def bulk_save(awards, fields=None) -> None:  # type: ignore[override]
+        """Bulk save awards."""
+        BulkSaveModel.bulk_save(Award, awards, fields=fields)
+
+    @staticmethod
+    def update_data(award_data: dict, *, save: bool = True) -> Award:
+        """Update award data.
 
         Args:
-            award_data: Dictionary containing award data from YAML
+            award_data: Dictionary containing single award winner data
             save: Whether to save the award instance
 
         Returns:
-            Award instance or list of Award instances
+            Award instance
 
         """
-        if award_data.get("type") == "award":
-            return Award._create_awards_from_winners(award_data, save=save)
-        return None
-
-    @staticmethod
-    def _create_awards_from_winners(award_data: dict, *, save: bool = True):
-        """Create award instances for each winner."""
-        awards = []
-        award_name = award_data.get("title", "")
+        # Create unique identifier for get_or_create
+        name = award_data.get("title", "")
         category = award_data.get("category", "")
         year = award_data.get("year")
-        winners = award_data.get("winners", [])
-
-        for winner_data in winners:
-            winner_name = winner_data.get("name", "").strip()
-            if not winner_name:
-                continue
-
-            award_defaults = {
-                "description": "",
-                "winner_info": winner_data.get("info", ""),
-                "winner_image_url": winner_data.get("image", ""),
-            }
-
-            if save:
-                award, created = Award.objects.get_or_create(
-                    name=award_name,
-                    category=category,
-                    year=year,
-                    winner_name=winner_name,
-                    defaults=award_defaults,
-                )
-                if not created:
-                    # Update existing award
-                    for field, value in award_defaults.items():
-                        setattr(award, field, value)
-                    award.save()
-            else:
-                award = Award(
-                    name=award_name,
-                    category=category,
-                    year=year,
-                    winner_name=winner_name,
-                    **award_defaults,
-                )
-
-            awards.append(award)
-
-        return awards
+        winner_name = award_data.get("name", "").strip()
+
+        try:
+            award = Award.objects.get(
+                name=name,
+                category=category,
+                year=year,
+                winner_name=winner_name,
+            )
+        except Award.DoesNotExist:
+            award = Award(
+                name=name,
+                category=category,
+                year=year,
+                winner_name=winner_name,
+            )
+
+        award.from_dict(award_data)
+        if save:
+            award.save()
+
+        return award
+
+    def from_dict(self, data: dict) -> None:
+        """Update instance based on dict data.
+
+        Args:
+            data: Dictionary containing award data
+
+        """
+        fields = {
+            "description": data.get("description", ""),
+            "winner_info": data.get("info", ""),
+            "winner_image_url": data.get("image", ""),
+        }
+
+        for key, value in fields.items():
+            setattr(self, key, value)