inventory_refresh 0.1.3 → 0.2.0

data/lib/inventory_refresh/save_collection/recursive.rb

@@ -1,52 +0,0 @@
-require "inventory_refresh/save_collection/base"
-
-module InventoryRefresh::SaveCollection
-  class Recursive < InventoryRefresh::SaveCollection::Base
-    class << self
-      # Saves the passed InventoryCollection objects by recursively passing the graph
-      #
-      # @param ems [ExtManagementSystem] manager owning the inventory_collections
-      # @param inventory_collections [Array<InventoryRefresh::InventoryCollection>] array of InventoryCollection objects
-      #        for saving
-      def save_collections(ems, inventory_collections)
-        graph = InventoryRefresh::InventoryCollection::Graph.new(inventory_collections)
-        graph.build_directed_acyclic_graph!
-
-        graph.nodes.each do |inventory_collection|
-          save_collection(ems, inventory_collection, [])
-        end
-      end
-
-      private
-
-      # Saves the one passed InventoryCollection object
-      #
-      # @param ems [ExtManagementSystem] manager owning the inventory_collections
-      # @param inventory_collection [InventoryRefresh::InventoryCollection] InventoryCollection object for saving
-      # @param traversed_collections [Array<InventoryRefresh::InventoryCollection>] array of traversed InventoryCollection
-      #        objects, that we use for detecting possible cycle
-      def save_collection(ems, inventory_collection, traversed_collections)
-        unless inventory_collection.kind_of?(::InventoryRefresh::InventoryCollection)
-          raise "A InventoryRefresh::SaveInventory needs a InventoryCollection object, it got: #{inventory_collection.inspect}"
-        end
-
-        return if inventory_collection.saved?
-
-        traversed_collections << inventory_collection
-
-        unless inventory_collection.saveable?
-          inventory_collection.dependencies.each do |dependency|
-            next if dependency.saved?
-            if traversed_collections.include?(dependency)
-              raise "Edge from #{inventory_collection} to #{dependency} creates a cycle"
-            end
-            save_collection(ems, dependency, traversed_collections)
-          end
-        end
-
-        logger.debug("Saving #{inventory_collection} of size #{inventory_collection.size}")
-        save_inventory_object_inventory(ems, inventory_collection)
-      end
-    end
-  end
-end

data/lib/inventory_refresh/save_collection/saver/concurrent_safe.rb

@@ -1,71 +0,0 @@
-require "inventory_refresh/save_collection/saver/base"
-
-module InventoryRefresh::SaveCollection
-  module Saver
-    class ConcurrentSafe < InventoryRefresh::SaveCollection::Saver::Base
-      # TODO(lsmola) this strategy does not make much sense, it's better to use concurent_safe_batch and make batch size
-      # configurable
-      private
-
-      # Updates the passed record with hash data and stores primary key value into inventory_object.
-      #
-      # @param record [ApplicationRecord] record we want to update in DB
-      # @param hash [Hash] data we want to update the record with
-      # @param inventory_object [InventoryRefresh::InventoryObject] InventoryObject instance where we will store primary
-      #        key value
-      def update_record!(record, hash, inventory_object)
-        assign_attributes_for_update!(hash, time_now)
-        record.assign_attributes(hash.except(:id))
-
-        if !inventory_object.inventory_collection.check_changed? || record.changed?
-          update_query = inventory_object.inventory_collection.model_class.where(:id => record.id)
-          if hash[:remote_data_timestamp]
-            timestamp_field = inventory_collection.model_class.arel_table[:remote_data_timestamp]
-            update_query    = update_query.where(timestamp_field.lt(hash[:remote_data_timestamp]))
-          end
-
-          update_query.update_all(hash)
-          inventory_collection.store_updated_records(record)
-        end
-
-        inventory_object.id = record.id
-      end
-
-      # Creates a new record in the DB using the passed hash data
-      #
-      # @param hash [Hash] hash with data we want to persist to DB
-      # @param inventory_object [InventoryRefresh::InventoryObject] InventoryObject instance where we will store primary
-      #        key value
-      def create_record!(hash, inventory_object)
-        all_attribute_keys = hash.keys
-        data               = inventory_collection.model_class.new(hash).attributes.symbolize_keys
-
-        # TODO(lsmola) abstract common behavior into base class
-        all_attribute_keys << :type if supports_sti?
-        all_attribute_keys << :created_at if supports_created_at?
-        all_attribute_keys << :updated_at if supports_updated_at?
-        all_attribute_keys << :created_on if supports_created_on?
-        all_attribute_keys << :updated_on if supports_updated_on?
-        hash_for_creation = if inventory_collection.use_ar_object?
-                              record = inventory_collection.model_class.new(data)
-                              values_for_database!(all_attribute_keys,
-                                                   record.attributes.symbolize_keys)
-                            elsif serializable_keys?
-                              values_for_database!(all_attribute_keys,
-                                                   data)
-                            else
-                              data
-                            end
-
-        assign_attributes_for_create!(hash_for_creation, time_now)
-
-        result_id = ActiveRecord::Base.connection.execute(
-          build_insert_query(all_attribute_keys, [hash_for_creation])
-        )
-
-        inventory_object.id = result_id.to_a.try(:first).try(:[], "id")
-        inventory_collection.store_created_records(inventory_object)
-      end
-    end
-  end
-end