Wip refactoring cleanup model

Refs #1933

1 files changed, 86 insertions, 103 deletions

diff --git a/app/models/clean_up.rb b/app/models/clean_up.rb
index cc8a6e537..986fbdd24 100644
--- a/app/models/clean_up.rb
+++ b/app/models/clean_up.rb
@@ -1,138 +1,121 @@
-class CleanUp
-  include ActiveModel::Validations
-  include ActiveModel::Conversion
-  extend ActiveModel::Naming
+class CleanUp < ActiveRecord::Base
+  include AASM
+  belongs_to :referential
+  validates :expected_date, presence: true
+  after_commit :perform_cleanup, :on => :create
 
-  attr_accessor :expected_date, :keep_lines, :keep_stops , :keep_companies
-  attr_accessor :keep_networks, :keep_group_of_lines
+  def perform_cleanup
+    CleanUpWorker.perform_async(self.id)
+  end
+
+  aasm column: :status do
+    state :new, :initial => true
+    state :pending
+    state :successful
+    state :failed
+
+    event :run, after: :update_started_at do
+      transitions :from => [:new, :failed], :to => :pending
+    end
 
-  validates_presence_of :expected_date
+    event :successful, after: :update_ended_at do
+      transitions :from => [:pending, :failed], :to => :successful
+    end
 
-  def initialize(attributes = {})
-    attributes.each do |name, value|
-      send("#{name}=", value)
+    event :failed, after: :update_ended_at do
+      transitions :from => :pending, :to => :failed
     end
   end
 
-  def persisted?
-    false
+  def update_started_at
+    update_attribute(:started_at, Time.now)
   end
 
-  def physical_stop_areas
-    Chouette::StopArea.physical.includes(:stop_points).where(:stop_points => {id: nil})
+  def update_ended_at
+    update_attribute(:ended_at, Time.now)
   end
 
-  def clean_physical_stop_areas
-     Chouette::StopArea.where(id: self.physical_stop_areas.pluck(:id)).delete_all
+  def clean
+    # as foreign keys are presents , delete method can be used for faster performance
+    # find and remove time_tables
+    result = CleanUpResult.new
+    tms = Chouette::TimeTable.validity_out_from_on?(expected_date)
+    result.time_table_count = tms.size
+    tms.each.map(&:delete)
+
+    result.vehicle_journey_count = self.clean_vehicle_journeys
+    result.journey_pattern_count = self.clean_journey_patterns
+    result.route_count           = self.clean_routes
+    result.line_count            = self.clean_lines unless keep_lines
+
+    unless keep_stops
+      result.stop_count += self.clean_physical_stop_areas
+      result.stop_count += self.clean_commercial_stop_areas
+      result.stop_count += self.clean_stop_place_stop_areas
+      result.stop_count += self.clean_itl_stop_areas
+    end
+
+    # If asked remove companies without lines or vehicle journeys
+    result.company_count       = self.clean_companies unless keep_companies
+    # If asked remove networks without lines
+    result.network_count       = self.clean_networks unless keep_networks
+    # If asked remove group_of_lines without lines
+    result.group_of_line_count = self.clean_group_of_lines unless keep_group_of_lines
+    result
   end
 
-  def commercial_stop_areas
-    Chouette::StopArea.commercial
+  def clean_physical_stop_areas
+    ids = Chouette::StopArea.physical.includes(:stop_points).where(:stop_points => {id: nil}).pluck(:id)
+    Chouette::StopArea.physical.where(id: ids).delete_all
   end
 
-  def stop_place_stop_areas
-    Chouette::StopArea.stop_place
+  def clean_commercial_stop_areas
+    ids = Chouette::StopArea.commercial.where.not(parent_id: nil).pluck(:parent_id)
+    Chouette::StopArea.commercial.where.not(id: ids).delete_all
   end
 
-  def itl_stop_areas
-    Chouette::StopArea.itl
+  def clean_stop_place_stop_areas
+    ids = Chouette::StopArea.stop_place.includes(:stop_points).where(:stop_points => {id: nil}).pluck(:id)
+    Chouette::StopArea.stop_place.where(id: ids).delete_all
   end
 
-  def vehicle_journeys
-    Chouette::VehicleJourney.includes(:time_tables).where(:time_tables => {id: nil})
+  def clean_itl_stop_areas
+    ids = Chouette::StopArea.itl.includes(:stop_points).where(:stop_points => {id: nil}).pluck(:id)
+    Chouette::StopArea.itl.where(id: ids).delete_all
   end
+
   def clean_vehicle_journeys
-    Chouette::VehicleJourney.where(id: self.vehicle_journeys.pluck(:id)).delete_all
+    ids = Chouette::VehicleJourney.includes(:time_tables).where(:time_tables => {id: nil}).pluck(:id)
+    Chouette::VehicleJourney.where(id: ids).delete_all
   end
 
-  def lines
-    Chouette::Line.includes(:routes).where(:routes => {id: nil})
-  end
   def clean_lines
-    Chouette::Line.where(id: self.lines.pluck(:id)).delete_all
+    ids = Chouette::Line.includes(:routes).where(:routes => {id: nil}).pluck(:id)
+    Chouette::Line.where(id: ids).delete_all
   end
 
-  def routes
-    Chouette::Route.includes(:journey_patterns).where(:journey_patterns => {id: nil})
-  end
   def clean_routes
-    Chouette::Route.where(id: self.routes.pluck(:id)).delete_all
+    ids = Chouette::Route.includes(:journey_patterns).where(:journey_patterns => {id: nil}).pluck(:id)
+    Chouette::Route.where(id: ids).delete_all
   end
 
-  def journey_patterns
-    Chouette::JourneyPattern.includes(:vehicle_journeys).where(:vehicle_journeys => {id: nil})
-  end
   def clean_journey_patterns
-    Chouette::JourneyPattern.where(id: self.journey_patterns.pluck(:id)).delete_all
+    ids = Chouette::JourneyPattern.includes(:vehicle_journeys).where(:vehicle_journeys => {id: nil}).pluck(:id)
+    Chouette::JourneyPattern.where(id: ids).delete_all
   end
 
-  def clean
-    # as foreign keys are presents , delete method can be used for faster performance
-    result = CleanUpResult.new
-    # find and remove time_tables
-    tms = Chouette::TimeTable.validity_out_from_on?(Date.parse(expected_date))
-    result.time_table_count = tms.size
-    tms.each do |tm|
-      tm.delete
-    end
-
-    result.vehicle_journey_count = self.clean_vehicle_journeys
-    result.journey_pattern_count = self.clean_journey_patterns
-    result.route_count           = self.clean_routes
-
-    result.line_count = self.clean_lines if keep_lines == "0"
-    result.stop_count = self.clean_physical_stop_areas if keep_stops == "0"
-
-    if keep_stops == "0"
-      commercial_stop_areas.find_each do |csp|
-        if csp.children.size == 0
-          result.stop_count += 1
-          csp.delete
-        end
-      end
-      stop_place_stop_areas.find_each do |sp|
-        if sp.children.size == 0
-          result.stop_count += 1
-          sp.delete
-        end
-      end
-      itl_stop_areas.find_each do |itl|
-        if itl.routing_stops.size == 0
-          result.stop_count += 1
-          itl.delete
-        end
-      end
-    end
-    # if asked remove companies without lines or vehicle journeys
-    if keep_companies == "0"
-      Chouette::Company.find_each do |c|
-        if c.lines.size == 0
-          result.company_count += 1
-          c.delete
-        end
-      end
-    end
-
-    # if asked remove networks without lines
-    if keep_networks == "0"
-      Chouette::Network.find_each do |n|
-        if n.lines.size == 0
-          result.network_count += 1
-          n.delete
-        end
-      end
-    end
+  def clean_companies
+    ids = Chouette::Company.includes(:lines).where(:lines => {id: nil}).pluck(:id)
+    Chouette::Company.where(id: ids).delete_all
+  end
 
-    # if asked remove group_of_lines without lines
-    if keep_group_of_lines == "0"
-      Chouette::GroupOfLine.find_each do |n|
-        if n.lines.size == 0
-          result.group_of_line_count += 1
-          n.delete
-        end
-      end
-    end
-    result
+  def clean_networks
+    ids = Chouette::Network.includes(:lines).where(:lines => {id: nil}).pluck(:id)
+    Chouette::Network.where(id: ids).delete_all
   end
 
+  def clean_group_of_lines
+    ids = Chouette::GroupOfLine.includes(:lines).where(:lines => {id: nil}).pluck(:id)
+    Chouette::GroupOfLine.where(id: ids).delete_all
+  end
 end