Fix deleteOrganismFeatures: add @transactional, flush deletes, use consistent organism lookup

- Add @transactional to deleteOrganismFeatures controller action (was inheriting
  readOnly=true from class, which could prevent writes in Grails 7)
- Use preferenceService.getOrganismForTokenInDB for organism lookup (handles both
  numeric IDs and common names consistently, matching other controller actions)
- Add flush:true to Feature.delete() and FeatureEvent.delete() calls in service
- Fix response.status set after render in error handler
- Add debug logging for delete operations
- Increase CI log output for delete diagnostics

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: cmdcolin

.github/workflows/python-apollo.yml

@@ -128,5 +128,8 @@ jobs:
       - name: Print Apollo log on failure
         if: failure()
         run: |
+          echo "=== Delete-related log lines ==="
+          grep -iE 'deleteOrganism|features to delete|Deleted.*features|problem removing|not authorized to delete' apollo.log | tail -50 || true
+          echo ""
           echo "=== Last 500 lines of Apollo log ==="
           tail -500 apollo.log

grails-app/controllers/org/bbop/apollo/OrganismController.groovy

@@ -167,6 +167,7 @@ class OrganismController {
     render responseObject as JSON
   }
 
+  @Transactional
   def deleteOrganismFeatures() {
     JSONObject organismJson = permissionService.handleInput(request, params)
     try {
@@ -181,11 +182,7 @@ class OrganismController {
         return
       }
 
-      Organism organism = Organism.findByCommonName(organismJson.organism)
-
-      if (!organism) {
-        organism = Organism.findById(organismJson.organism)
-      }
+      Organism organism = preferenceService.getOrganismForTokenInDB(organismJson.organism as String)
 
       if (!organism) {
         throw new Exception("Can not find organism for ${organismJson.organism} to remove features of")
@@ -194,18 +191,20 @@ class OrganismController {
       if (organismJson.sequences) {
         List<String> sequenceNames = organismJson.sequences.toString().split(",")
         List<Sequence> sequences = Sequence.findAllByOrganismAndNameInList(organism, sequenceNames)
-        organismService.deleteAllFeaturesForSequences(sequences)
+        int deleted = organismService.deleteAllFeaturesForSequences(sequences)
+        log.info "Deleted ${deleted} features for sequences ${sequenceNames} of organism ${organism.commonName}"
       } else {
-        organismService.deleteAllFeaturesForOrganism(organism)
+        int deleted = organismService.deleteAllFeaturesForOrganism(organism)
+        log.info "Deleted ${deleted} features for organism ${organism.commonName}"
       }
 
       render [:] as JSON
     }
     catch (Exception e) {
       def error = [error: 'problem removing organism features for organism: ' + e]
-      render error as JSON
-      response.status = HttpStatus.INTERNAL_SERVER_ERROR.value()
       log.error(error.error, e)
+      response.status = HttpStatus.INTERNAL_SERVER_ERROR.value()
+      render error as JSON
     }
   }
 

grails-app/services/org/bbop/apollo/OrganismService.groovy

@@ -71,12 +71,13 @@ class OrganismService {
                     log.debug "uniqueNames ${uniqueNames.size()}"
                     Feature.withNewTransaction{
                         def features = Feature.findAllByIdInList(ids)
+                        log.debug "Found ${features.size()} features for deletion"
                         for (f in features) {
-                            f.delete()
+                            f.delete(flush: true)
                         }
                         def featureEvents = FeatureEvent.findAllByUniqueNameInList(uniqueNames)
                         for (fe in featureEvents) {
-                            fe.delete()
+                            fe.delete(flush: true)
                         }
                         count += featureList.size()
                         log.info "${count} / ${featurePairs.size()}  =  ${100 * count / featurePairs.size()}% "
@@ -102,7 +103,7 @@ class OrganismService {
         int totalDeleted = 0
         log.debug "organism ${organism}"
         def featureCount = Feature.executeQuery("select count(f) from Feature f join f.featureLocations fl join fl.sequence s join s.organism o where o=:organism", [organism: organism])[0]
-        log.debug "features to delete ${featureCount}"
+        log.info "features to delete ${featureCount} for organism ${organism.commonName}"
         while(featureCount>0){
             def featurePairs = Feature.executeQuery("select f.id,f.uniqueName from Feature f join f.featureLocations fl join fl.sequence s join s.organism o where o=:organism", [max:MAX_DELETE_SIZE,organism: organism])
             // maximum transaction size  30
@@ -127,14 +128,14 @@ class OrganismService {
                     log.debug "uniqueNames ${uniqueNames.size()}"
                     Feature.withNewTransaction{
                         def features = Feature.findAllByIdInList(ids)
+                        log.debug "Found ${features.size()} features for deletion"
                         for (f in features) {
-                            f.delete()
+                            f.delete(flush: true)
                         }
                         def featureEvents = FeatureEvent.findAllByUniqueNameInList(uniqueNames)
                         for (fe in featureEvents) {
-                            fe.delete()
+                            fe.delete(flush: true)
                         }
-                        organism.save(flush: true)
                         count += featureList.size()
                         log.info "${count} / ${featurePairs.size()}  =  ${100 * count / featurePairs.size()}% "
                     }