Remove extra logging from destroy_locations

It was decided that this level of logging was unnecessary after
`PatientDeleter` was introduced, particularly because of the
introduction of the unit test which checks which FK relationships
are deleted by the `PatientDeleter`

Jira-Issue: MAV-7067

Author: alistair-white-horne-tng

app/controllers/api/testing/teams_controller.rb

@@ -14,70 +14,64 @@ def destroy
 
     @start_time = Time.zone.now
 
-    log_destroy(CohortImport.where(team:))
-    log_destroy(ImmunisationImport.where(team:))
-    log_destroy(ClassImport.where(team:))
-
-    log_destroy(Consent.where(team:))
-    log_destroy(ArchiveReason.where(team:))
-    log_destroy(ImportantNotice.where(team:))
-
-    log_destroy(
-      NotifyLogEntry.joins(:team_location).where(team_location: { team_id: })
-    )
-    log_destroy(ConsentForm.for_team(team))
-
-    log_destroy(ClinicNotification.where(team_id:))
-    log_destroy(
-      ConsentNotification.joins(session: :team_location).where(
-        team_location: {
-          team_id:
-        }
-      )
-    )
-    log_destroy(
-      ConsentNotification.joins(:team_location).where(
-        team_location: {
-          team_id:
-        }
-      )
-    )
-    log_destroy(
-      SessionNotification.joins(session: :team_location).where(
-        team_location: {
-          team_id:
-        }
-      )
-    )
-    log_destroy(
-      VaccinationRecord.joins(session: :team_location).where(
-        team_locations: {
-          team_id:
-        }
-      )
-    )
+    CohortImport.where(team:).delete_all
+    ImmunisationImport.where(team:).delete_all
+    ClassImport.where(team:).delete_all
+
+    Consent.where(team:).delete_all
+    ArchiveReason.where(team:).delete_all
+    ImportantNotice.where(team:).delete_all
+
+    NotifyLogEntry
+      .joins(:team_location)
+      .where(team_location: { team_id: })
+      .delete_all
+
+    ConsentForm.for_team(team).delete_all
+
+    ClinicNotification.where(team_id:).delete_all
+
+    ConsentNotification
+      .joins(session: :team_location)
+      .where(team_location: { team_id: })
+      .delete_all
+
+    ConsentNotification
+      .joins(:team_location)
+      .where(team_location: { team_id: })
+      .delete_all
+
+    SessionNotification
+      .joins(session: :team_location)
+      .where(team_location: { team_id: })
+      .delete_all
+
+    VaccinationRecord
+      .joins(session: :team_location)
+      .where(team_locations: { team_id: })
+      .delete_all
 
     # In local dev we can end up with NotifyLogEntries without a patient
-    log_destroy(NotifyLogEntry.where(patient_id: nil))
+    NotifyLogEntry.where(patient_id: nil).delete_all
 
-    log_destroy_patients(patients: team.patients)
+    PatientDeleter.call(patients: team.patients)
 
-    log_destroy(Batch.where(team:))
+    Batch.where(team:).delete_all
 
-    log_destroy(
-      VaccinationRecord.where(performed_ods_code: team.organisation.ods_code)
-    )
+    VaccinationRecord.where(
+      performed_ods_code: team.organisation.ods_code
+    ).delete_all
 
-    log_destroy(Triage.where(team:))
+    Triage.where(team:).delete_all
 
     TeamCachedCounts.new(team).reset_all!
 
-    log_destroy(Session.for_team(team))
+    Session.for_team(team).delete_all
 
     unless keep_itself
-      log_destroy(TeamLocation.where(team:))
-      log_destroy(Subteam.where(team:))
-      log_destroy(Team.where(id: team.id))
+      TeamLocation.where(team:).delete_all
+      Subteam.where(team:).delete_all
+      Team.where(id: team.id).delete_all
     end
 
     response.stream.write "Done"
@@ -103,28 +97,28 @@ def destroy_locations
 
     location_ids_to_delete = locations.pluck(:id)
 
-    log_destroy(AttendanceRecord.where(location_id: location_ids_to_delete))
-    log_destroy(ClassImport.where(location_id: location_ids_to_delete))
-    log_destroy(GillickAssessment.where(location_id: location_ids_to_delete))
-    log_destroy(PatientLocation.where(location_id: location_ids_to_delete))
-    log_destroy(PreScreening.where(location_id: location_ids_to_delete))
+    AttendanceRecord.where(location_id: location_ids_to_delete).delete_all
+    ClassImport.where(location_id: location_ids_to_delete).delete_all
+    GillickAssessment.where(location_id: location_ids_to_delete).delete_all
+    PatientLocation.where(location_id: location_ids_to_delete).delete_all
+    PreScreening.where(location_id: location_ids_to_delete).delete_all
 
     team_location_ids =
       TeamLocation.where(location_id: location_ids_to_delete).pluck(:id)
-    log_destroy(Session.where(team_location_id: team_location_ids))
-    log_destroy(TeamLocation.where(location_id: location_ids_to_delete))
+    Session.where(team_location_id: team_location_ids).delete_all
+    TeamLocation.where(location_id: location_ids_to_delete).delete_all
 
-    log_destroy(VaccinationRecord.where(location_id: location_ids_to_delete))
+    VaccinationRecord.where(location_id: location_ids_to_delete).delete_all
 
     location_year_group_ids =
       Location::YearGroup.where(location_id: location_ids_to_delete).pluck(:id)
-    log_destroy(
-      Location::ProgrammeYearGroup.where(
-        location_year_group_id: location_year_group_ids
-      )
-    )
-    log_destroy(Location::YearGroup.where(location_id: location_ids_to_delete))
-    log_destroy(locations)
+
+    Location::ProgrammeYearGroup.where(
+      location_year_group_id: location_year_group_ids
+    ).delete_all
+
+    Location::YearGroup.where(location_id: location_ids_to_delete).delete_all
+    locations.delete_all
 
     if keep_base_locations
       Location.where(id: location_ids, site: "A").update_all(site: nil)
@@ -137,22 +131,4 @@ def destroy_locations
   ensure
     response.stream.close
   end
-
-  private
-
-  def log_destroy(query)
-    where_clause = query.where_clause
-    @log_time ||= Time.zone.now
-    query.delete_all
-    response.stream.write(
-      "#{query.model.name}.where(#{where_clause.to_h}): #{Time.zone.now - @log_time}s\n"
-    )
-    @log_time = Time.zone.now
-  end
-
-  def log_destroy_patients(patients:)
-    PatientDeleter.call(patients:)
-    response.stream.write("PatientDeleter.call(patients: team.patients)")
-    @log_time = Time.zone.now
-  end
 end