refactor: prefix doi management commands

- prefix all one-off destructive DOI commands with `doi_`
- add reset_staging to mint new DOIs on staging using the datacite
  sandbox, doi_reset_staging -> step 3, doi_mint_parent_codebase_dois
- bump deps for datacite schema 4.5 and django cve

django/library/doi.py

@@ -18,7 +18,7 @@
     DataCiteRegistrationLog,
 )
 
-from datacite import DataCiteRESTClient, schema43
+from datacite import DataCiteRESTClient, schema45
 from datacite.errors import (
     DataCiteError,
     DataCiteNoContentError,
@@ -183,8 +183,12 @@ def _datacite_heartbeat_url(self):
 
     def _validate_metadata(self, datacite_metadata: DataCiteSchema):
         metadata_dict = datacite_metadata.to_dict()
-        if not schema43.validate(metadata_dict):
-            logger.error("Invalid DataCite metadata: %s", metadata_dict)
+        try:
+            schema45.validator.validate(metadata_dict)
+        except Exception as e:
+            logger.error(
+                "Invalid DataCite metadata: %s", schema45.tostring(metadata_dict), e
+            )
             raise DataCiteError(f"Invalid DataCite metadata: {metadata_dict}")
         return datacite_metadata, metadata_dict
 
@@ -202,17 +206,22 @@ def mint_public_doi(self, codebase_or_release: Codebase | CodebaseRelease):
             return "XX.DRYXX/XXXX-XRUN", True
         if hasattr(codebase_or_release, "datacite"):
             del codebase_or_release.datacite
-        datacite_metadata, metadata_dict = self._validate_metadata(
-            codebase_or_release.datacite
-        )
+
         doi = "Unassigned"
         http_status = 200
         message = "Minted new DOI successfully."
 
+        datacite_metadata = codebase_or_release.datacite
+
         try:
+            datacite_metadata, metadata_dict = self._validate_metadata(
+                datacite_metadata
+            )
             doi = self.datacite_client.public_doi(
                 metadata_dict, url=codebase_or_release.permanent_url
             )
+            codebase_or_release.doi = doi
+            codebase_or_release.save()
         except DataCiteError as e:
             logger.error(e)
             message = str(e)
@@ -235,7 +244,27 @@ def mint_public_doi(self, codebase_or_release: Codebase | CodebaseRelease):
         self._save_log_record(**log_record_dict)
         return doi, http_status == 200
 
+    @classmethod
+    def is_metadata_fresh(cls, codebase_or_release: Codebase | CodebaseRelease):
+        try:
+            newest_log_entry = DataCiteRegistrationLog.objects.latest_entry(
+                codebase_or_release
+            )
+            # make sure item does not have stale datacite metadata
+            if hasattr(codebase_or_release, "datacite"):
+                del codebase_or_release.datacite
+            return newest_log_entry.metadata_hash == codebase_or_release.datacite.hash()
+
+        except DataCiteRegistrationLog.DoesNotExist:
+            # no logs for this item, metadata is stale
+            logger.info("No registration logs available for %s", codebase_or_release)
+
+        return False
+
     def update_doi_metadata(self, codebase_or_release: Codebase | CodebaseRelease):
+        if self.is_metadata_fresh(codebase_or_release):
+            logger.info("No need to update DOI metadata for %s", codebase_or_release)
+            return True
         doi = codebase_or_release.doi
         if self.dry_run:
             logger.debug("DRY RUN")
@@ -278,16 +307,10 @@ def update_doi_metadata(self, codebase_or_release: Codebase | CodebaseRelease):
         self._save_log_record(**log_record_dict)
         return http_status == 200
 
-    def mint_new_doi_for_codebase(self, codebase: Codebase) -> str:
-        return self.mint_public_doi(codebase)
-
-    def mint_new_doi_for_release(self, release: CodebaseRelease) -> str:
-        return self.mint_public_doi(release)
-
-    def update_metadata_for_codebase(self, codebase: Codebase) -> bool:
+    def update_codebase_metadata(self, codebase: Codebase) -> bool:
         return self.update_doi_metadata(codebase)
 
-    def update_metadata_for_release(self, release: CodebaseRelease) -> bool:
+    def update_release_metadata(self, release: CodebaseRelease) -> bool:
         return self.update_doi_metadata(release)
 
     @staticmethod
@@ -398,25 +421,35 @@ def _is_same_metadata(sent_data, received_data):
             logger.debug("Missing attributes:", missing_attributes)
             return False
 
-    def check_metadata(self, item) -> bool:
+    def check_metadata(self, codebase_or_release: Codebase | CodebaseRelease) -> bool:
         """
         1. get metadata for item.doi
         2. compare if the values match codebase.datacite.metadata
 
         - item: Codebase | CodebaseRelease
         """
-        if not item.doi:
+        if self.dry_run:
+            logger.debug(
+                "Dry run metadata check for %s", codebase_or_release.datacite.to_dict()
+            )
+            return True
+        if not codebase_or_release.doi:
+            logger.warning(
+                "Unnecessary metadata check for non-DOI codebase or release %s",
+                codebase_or_release,
+            )
             return False
         try:
-            if not self.dry_run:
-                comses_metadata = item.datacite.to_dict()
-                datacite_metadata = self.datacite_client.get_metadata(item.doi)
-                return DataCiteApi._is_same_metadata(comses_metadata, datacite_metadata)
-            else:
-                logger.debug(
-                    f"{'Codebase' if isinstance(item, Codebase) else 'CodebaseRelease'} metadata is in sync!"
-                )
-                return True
+            comses_metadata = codebase_or_release.datacite.to_dict()
+            datacite_metadata = self.datacite_client.get_metadata(
+                codebase_or_release.doi
+            )
+            logger.debug(
+                "comparing datacite metadata\n\n%s\n\nwith comses metadata\n\n%s",
+                datacite_metadata,
+                comses_metadata,
+            )
+            return DataCiteApi._is_same_metadata(comses_metadata, datacite_metadata)
         except Exception as e:
             logger.error(e)
             return False
@@ -431,7 +464,7 @@ def loading_animation(thread):
         def _check_metadata(q: queue.Queue):
             with ThreadPoolExecutor(max_workers=MAX_DATACITE_API_WORKERS) as executor:
                 results = executor.map(
-                    lambda item: (item.pk, self.check_metadata(item)), items
+                    lambda item: (item, self.check_metadata(item)), items
                 )
 
             q.put(results)
@@ -524,7 +557,7 @@ def mint_dois_for_peer_reviewed_releases_without_dois(interactive=True, dry_run=
         """
         if not codebase_doi:
             # request to DataCite API
-            codebase_doi = datacite_api.mint_new_doi_for_codebase(codebase)
+            codebase_doi = datacite_api.mint_public_doi(codebase)
 
             if not codebase_doi:
                 logger.error(
@@ -544,7 +577,7 @@ def mint_dois_for_peer_reviewed_releases_without_dois(interactive=True, dry_run=
         Mint DOI for release
         """
         # request to DataCite API
-        release_doi = datacite_api.mint_new_doi_for_release(release)
+        release_doi = datacite_api.mint_public_doi(release)
         if not release_doi:
             logger.error("Could not mint DOI for release %s. Skipping.", release.pk)
             if interactive:
@@ -559,7 +592,7 @@ def mint_dois_for_peer_reviewed_releases_without_dois(interactive=True, dry_run=
         """
         Since a new DOI has been minted for the release, we need to update it's parent's metadata (HasVersion)
         """
-        ok = datacite_api.update_metadata_for_codebase(codebase)
+        ok = datacite_api.update_codebase_metadata(codebase)
         if not ok:
             logger.error("Failed to update metadata for codebase %s", codebase.pk)
 
@@ -572,15 +605,15 @@ def mint_dois_for_peer_reviewed_releases_without_dois(interactive=True, dry_run=
         next_release = release.get_next_release()
 
         if previous_release and previous_release.doi:
-            ok = datacite_api.update_metadata_for_release(previous_release)
+            ok = datacite_api.update_release_metadata(previous_release)
             if not ok:
                 logger.error(
                     "Failed to update metadata for previous_release %s",
                     previous_release.pk,
                 )
 
         if next_release and next_release.doi:
-            ok = datacite_api.update_metadata_for_release(next_release)
+            ok = datacite_api.update_release_metadata(next_release)
             if not ok:
                 logger.error(
                     "Failed to update metadata for next_release %s", next_release.pk
@@ -619,7 +652,7 @@ def mint_dois_for_peer_reviewed_releases_without_dois(interactive=True, dry_run=
         if invalid_codebases:
             logger.error(
                 "FAILURE: %s Codebases with invalid or missing DOIs: %s",
-                invalid_codebases.count(),
+                len(invalid_codebases),
                 invalid_codebases,
             )
         else:

django/library/management/commands/fix_existing_dois_03.py → django/library/management/commands/doi_mint_parent_codebases.py

@@ -29,7 +29,7 @@ def update_existing_dois(interactive=True, dry_run=True):
     total_peer_reviewed_releases_count = peer_reviewed_releases.count()
 
     logger.info(
-        "Updating DOIs for %s peer reviewed CodebaseReleases with DOIs",
+        "Updating DOIs for parent Codebases of %s peer reviewed CodebaseReleases with DOIs",
         total_peer_reviewed_releases_count,
     )
 
@@ -56,7 +56,7 @@ def update_existing_dois(interactive=True, dry_run=True):
         if not codebase_doi:
             # request to DataCite API
             logger.debug("Minting DOI for parent codebase: %s", codebase.pk)
-            codebase_doi, success = datacite_api.mint_new_doi_for_codebase(codebase)
+            codebase_doi, success = datacite_api.mint_public_doi(codebase)
 
             if not success:
                 logger.error(
@@ -108,7 +108,7 @@ def update_existing_dois(interactive=True, dry_run=True):
                 release_doi,
             )
             # set up DataCite API request to mint new DOI
-            release_doi, success = datacite_api.mint_new_doi_for_release(release)
+            release_doi, success = datacite_api.mint_public_doi(release)
             if not success:
                 logger.error(
                     "Could not mint DOI for release %s. DOI: %s. Skipping.",
@@ -139,7 +139,7 @@ def update_existing_dois(interactive=True, dry_run=True):
                 release_doi,
             )
             # request to DataCite API: mint new DOI!
-            release_doi, success = datacite_api.mint_new_doi_for_release(release)
+            release_doi, success = datacite_api.mint_public_doi(release)
             if not success:
                 logger.error(
                     "Could not mint DOI for release %s. DOI: %s. Skipping.",
@@ -214,7 +214,7 @@ def add_arguments(self, parser):
             "--interactive",
             action="store_true",
             help="Wait for user to press enter to continue.",
-            default=True,
+            default=False,
         )
         parser.add_argument(
             "--dry-run", action="store_true", help="Output what would have happened."