datashift_spree 0.1.0

data/lib/loaders/spree/product_loader.rb

@@ -0,0 +1,359 @@
+# Copyright:: (c) Autotelik Media Ltd 2010
+# Author ::   Tom Statter
+# Date ::     Aug 2010
+# License::   MIT ?
+#
+# Details::   Specific over-rides/additions to support Spree Products
+#
+require 'loader_base'
+require 'csv_loader'
+require 'excel_loader'
+
+require 'image_loading'
+
+module DataShift
+
+  module SpreeHelper
+
+    class ProductLoader < LoaderBase
+
+      include DataShift::CsvLoading
+      include DataShift::ExcelLoading
+      include DataShift::ImageLoading
+
+      # depending on version get_product_class should return us right class, namespaced or not
+
+      def initialize(product = nil)
+        super( DataShift::SpreeHelper::get_product_class(), product, :instance_methods => true  )
+     
+        @@image_klass ||= DataShift::SpreeHelper::get_spree_class('Image')
+        @@option_type_klass ||= DataShift::SpreeHelper::get_spree_class('OptionType')
+        @@option_value_klass ||= DataShift::SpreeHelper::get_spree_class('OptionValue')
+        @@property_klass ||= DataShift::SpreeHelper::get_spree_class('Property')
+        @@product_property_klass ||= DataShift::SpreeHelper::get_spree_class('ProductProperty')
+        @@taxonomy_klass ||= DataShift::SpreeHelper::get_spree_class('Taxonomy')
+        @@taxon_klass ||= DataShift::SpreeHelper::get_spree_class('Taxon')
+        @@variant_klass ||= DataShift::SpreeHelper::get_spree_class('Variant')
+        
+        raise "Failed to create Product for loading" unless @load_object
+        
+        logger.debug "PRODUCT #{@load_object.inspect} MASTER: #{@load_object.master.inspect}"
+      end
+
+      def perform_load( file_name, options = {} )
+         # In >= 1.1.0 Image moved to master Variant from Product so no association called Images on Product anymore
+        options[:force_inclusion] = options[:force_inclusion] ? ['images'] : [*options[:force_inclusion]] << 'images'
+    
+        super(file_name, options)
+      end
+
+      # Over ride base class process with some Spree::Product specifics
+      #
+      # What process a value string from a column, assigning value(s) to correct association on Product.
+      # Method map represents a column from a file and it's correlated Product association.
+      # Value string which may contain multiple values for a collection (has_many) association.
+      #
+      def process()
+
+        # Special cases for Products, generally where a simple one stage lookup won't suffice
+        # otherwise simply use default processing from base class
+        if(current_value && (@current_method_detail.operator?('variants') || @current_method_detail.operator?('option_types')) )
+
+          add_options
+
+        elsif(@current_method_detail.operator?('taxons') && current_value)
+
+          add_taxons
+
+        elsif(@current_method_detail.operator?('product_properties') && current_value)
+
+          add_properties
+
+        elsif(@current_method_detail.operator?('images') && current_value)
+
+          add_images
+          
+        elsif(current_value && (@current_method_detail.operator?('count_on_hand') || @current_method_detail.operator?('on_hand')) )
+
+
+          # Unless we can save here, in danger of count_on_hand getting wiped out.
+          # If we set (on_hand or count_on_hand) on an unsaved object, during next subsequent save
+          # looks like some validation code or something calls Variant.on_hand= with 0
+          # If we save first, then our values seem to stick
+
+          # TODO smart column ordering to ensure always valid - if we always make it very last column might not get wiped ?
+          # 
+          save_if_new
+          
+  
+          # Spree has some stock management stuff going on, so dont usually assign to column vut use
+          # on_hand and on_hand=
+          if(@load_object.variants.size > 0)
+            
+            if(current_value.to_s.include?(LoaderBase::multi_assoc_delim))
+
+              #puts "DEBUG: COUNT_ON_HAND PER VARIANT",current_value.is_a?(String),
+          
+              # Check if we processed Option Types and assign count per option
+              values = current_value.to_s.split(LoaderBase::multi_assoc_delim)
+
+              if(@load_object.variants.size == values.size)
+                @load_object.variants.each_with_index {|v, i| v.on_hand = values[i].to_i }
+                @load_object.save
+              else
+                puts "WARNING: Count on hand entries did not match number of Variants - None Set"
+              end
+            end
+            
+          # Can only set count on hand on Product if no Variants exist, else model throws
+            
+          elsif(@load_object.variants.size == 0) 
+            if(current_value.to_s.include?(LoaderBase::multi_assoc_delim))
+              puts "WARNING: Multiple count_on_hand values specified but no Variants/OptionTypes created" 
+              load_object.on_hand = current_value.to_s.split(LoaderBase::multi_assoc_delim).first.to_i
+            else
+              load_object.on_hand = current_value.to_i
+            end
+          end
+
+        else
+          super
+        end
+      end
+
+      private
+
+      # Special case for OptionTypes as it's two stage process
+      # First add the possible option_types to Product, then we are able
+      # to define Variants on those options values.
+      #  To defiene a Variant : 
+      #  1) define at least one OptionType on Product, for example Size
+      #  2) Provide a value for at least one of these OptionType
+      #  3) A composite Variant can be created by supplyiung a vlaue for more than one OptionType
+      #       fro example Colour : Red and Size Medium
+      # Supported Syntax :
+      #  '|' seperates Variants
+      #   ',' list of option values
+      #  Examples : 
+      #     mime_type:jpeg;print_type:black_white|mime_type:jpeg|mime_type:png, PDF;print_type:colour
+      #
+      def add_options
+        
+        # TODO smart column ordering to ensure always valid by time we get to associations
+        save_if_new
+
+        # example : mime_type:jpeg;print_type:black_white|mime_type:jpeg|mime_type:png, PDF;print_type:colour
+        
+        variants = get_each_assoc#current_value.split( LoaderBase::multi_assoc_delim )
+
+        # 1) mime_type:jpeg;print_type:black_white  2) mime_type:jpeg  3) mime_type:png, PDF;print_type:colour
+
+        variants.each do |per_variant| 
+                
+          option_types = per_variant.split(';')    # [mime_type:jpeg, print_type:black_white]   
+          
+          optiontype_vlist_map = {}
+                      
+          option_types.each do |ostr|
+             
+            oname, value_str = ostr.split(LoaderBase::name_value_delim)
+    
+            option_type = @@option_type_klass.find_by_name(oname)
+
+            unless option_type
+              option_type = @@option_type_klass.create( :name => oname, :presentation => oname.humanize)
+              # TODO - dynamic creation should be an option
+
+              unless option_type
+                puts "WARNING: OptionType #{oname} NOT found and could not create - Not set Product"
+                next
+              end
+              puts "Created missing OptionType #{option_type.inspect}"
+            end
+
+            # OptionTypes must be specified first on Product to enable Variants to be created
+            # TODO - is include? very inefficient ??
+            @load_object.option_types << option_type unless @load_object.option_types.include?(option_type)
+
+            # Can be simply list of OptionTypes, some or all without values
+            next unless(value_str)
+
+            optiontype_vlist_map[option_type] = []
+            
+            # Now get the value(s) for the option e.g red,blue,green for OptType 'colour'   
+            optiontype_vlist_map[option_type] = value_str.split(',')
+          end
+         
+          next if(optiontype_vlist_map.empty?) # only option types specified - no values
+
+          # Now create set of Variants, some of which maybe composites           
+          # Find the longest set of OVs to use as base for combining with the rest
+          sorted_map = optiontype_vlist_map.sort_by { |k,v| v.size }.reverse
+          
+          # ovalues = 'pdf','jpeg','png'
+          option_type, ovalues = sorted_map.shift
+          # TODO .. benchmarking to find most efficient way to create these but ensure Product.variants list
+          # populated .. currently need to call reload to ensure this (seems reqd for Spree 1/Rails 3, wasn't required b4
+          ovalues.each do |ovname|
+              
+            ov_list = []
+          
+            ov = @@option_value_klass.find_or_create_by_name_and_option_type_id(ovname.strip, option_type.id)
+                
+            ov_list << ov if ov
+              
+            sorted_map.each do |ot, ovlist| ovlist.each do |for_composite|
+                ov = @@option_value_klass.find_or_create_by_name_and_option_type_id(for_composite.strip, ot.id)
+                
+                ov_list << ov if(ov)
+              end 
+            end
+
+            unless(ov_list.empty?)
+              i = @load_object.variants.size + 1
+              
+              # This one line seems to works for 1.1.0 - 3.2 but not 1.0.0 - 3.1 ??
+              if(SpreeHelper::version.to_f >= 1.1)
+                variant = @load_object.variants.create( :sku => "#{@load_object.sku}_#{i}", :price => @load_object.price)
+              else
+                variant = @@variant_klass.create( :product => @load_object, :sku => "#{@load_object.sku}_#{i}", :price => @load_object.price, :available_on => @load_object.available_on)
+              end
+
+              variant.option_values << ov_list if(variant)
+            end
+          end
+          
+          #puts "DEBUG Load Object now has Variants : #{@load_object.variants.inspect}"
+          @load_object.reload unless @load_object.new_record? 
+          #puts "DEBUG Load Object now has Variants : #{@load_object.variants.inspect}"
+        end
+
+      end # each Variant
+
+      # Special case for Images
+      # A list of paths to Images with a optional 'alt' value - supplied in form :
+      #   path:alt|path2:alt2|path_3:alt3 etc
+      #
+      def add_images
+        # TODO smart column ordering to ensure always valid by time we get to associations
+        save_if_new
+
+        images = get_each_assoc#current_value.split(LoaderBase::multi_assoc_delim)
+
+        images.each do |image|
+          puts "Add Image #{image}"
+          img_path, alt_text = image.split(LoaderBase::name_value_delim)
+          
+          # moved from Prod to Variant in spree 1.x.x
+          attachment  = (SpreeHelper::version.to_f > 1) ? @load_object.master : @load_object
+          
+          image = create_image(@@image_klass, img_path, attachment, :alt => alt_text)
+          logger.debug("Product assigned an Image : #{image.inspect}")
+        end
+      
+      end
+
+      
+      # Special case for ProductProperties since it can have additional value applied.
+      # A list of Properties with a optional Value - supplied in form :
+      #   property_name:value|property_name|property_name:value
+      #  Example :
+      #  test_pp_002|test_pp_003:Example free value|yet_another_property
+
+      def add_properties
+        # TODO smart column ordering to ensure always valid by time we get to associations
+        save_if_new
+
+        property_list = get_each_assoc#current_value.split(LoaderBase::multi_assoc_delim)
+
+        property_list.each do |pstr|
+        
+          # Special case, we know we lookup on name so operator is effectively the name to lookup
+          find_by_name, find_by_value = get_find_operator_and_rest( pstr )
+     
+          raise "Cannot find Property via #{find_by_name} (with value #{find_by_value})" unless(find_by_name)
+                        
+          property = @@property_klass.find_by_name(find_by_name)
+
+          unless property
+            property = @@property_klass.create( :name => find_by_name, :presentation => find_by_name.humanize)
+            logger.info "Created New Property #{property.inspect}"
+          end
+
+          if(property)
+            if(SpreeHelper::version.to_f >= 1.1)
+              # Property now protected from mass assignment 
+              x = @@product_property_klass.new( :value => find_by_value )
+              x.property = property
+              x.save
+              @load_object.product_properties << x 
+              logger.info "Created New ProductProperty #{x.inspect}"
+            else
+              @load_object.product_properties << @@product_property_klass.create( :property => property, :value => find_by_values)
+            end
+          else
+            puts "WARNING: Property #{find_by_name} NOT found - Not set Product"
+          end
+         
+        end
+      
+      end
+
+      # Nested tree structure support ..
+      # TAXON FORMAT 
+      # name|name>child>child|name
+       
+      def add_taxons
+        # TODO smart column ordering to ensure always valid by time we get to associations
+        save_if_new
+
+        chain_list = get_each_assoc  # potentially multiple chains in single column (delimited by LoaderBase::multi_assoc_delim)
+
+        chain_list.each do |chain|
+  
+          # Each chain can contain either a single Taxon, or the tree like structure parent>child>child  
+          name_list = chain.split(/\s*>\s*/)
+                            
+          parent_name = name_list.shift
+          
+          parent_taxonomy = @@taxonomy_klass.find_or_create_by_name(parent_name)
+          
+          raise "Could not find or create Taxonomy #{parent_name}" unless parent_taxonomy 
+          
+          parent = parent_taxonomy.root
+          
+          # Add the Taxons to Taxonomy from tree structure parent>child>child  
+          taxons = name_list.collect do |name|
+                     
+            begin
+              taxon = @@taxon_klass.find_or_create_by_name_and_parent_id_and_taxonomy_id(name, parent && parent.id, parent_taxonomy.id)        
+
+              unless(taxon)
+                puts "Not found or created so now what ?"      
+              end
+            rescue => e
+              puts e.inspect
+              puts "ERROR : Cannot assign Taxon ['#{taxon}'] to Product ['#{load_object.name}']"
+              next
+            end
+            
+            parent = taxon  # current taxon becomes next parent
+            taxon
+          end
+          
+          taxons << parent_taxonomy.root
+          
+          unique_list = taxons.compact.uniq - (@load_object.taxons || [])
+        
+          logger.debug("Product assigned to Taxons : #{unique_list.collect(&:name).inspect}")
+          
+          @load_object.taxons << unique_list unless(unique_list.empty?)
+         # puts @load_object.taxons.inspect
+          
+        end
+
+      end
+
+    end
+  end
+end

data/lib/thor/spree/bootstrap_cleanup.thor

@@ -0,0 +1,61 @@
+# Copyright:: (c) Autotelik Media Ltd 2012
+# Author ::   Tom Statter
+# Date ::     March 2012
+# License::   MIT. Free, Open Source.
+#
+# Usage::
+# bundle exec thor help datashift:spreeboot
+# bundle exec thor datashift:spreeboot:cleanup
+#
+# Note, not DataShift, case sensitive, create namespace for command line : datashift
+
+module Datashift
+        
+  class Spreeboot < Thor     
+  
+    include DataShift::Logging
+       
+    desc "cleanup", "Remove Spree Product/Variant data from DB"
+    
+    def cleanup()
+
+      require File.expand_path('config/environment.rb')
+
+      require 'spree_helper'
+
+      require File.expand_path('config/environment.rb')
+
+      ActiveRecord::Base.connection.execute("TRUNCATE spree_products_taxons")
+      
+      cleanup =  %w{ Image OptionType OptionValue 
+                    Product Property ProductGroup ProductProperty ProductOptionType 
+                    Variant Taxonomy Taxon
+      }
+
+      cleanup.each do |k|
+        klass = DataShift::SpreeHelper::get_spree_class(k)
+        if(klass)
+          puts "Clearing model #{klass}"
+          begin
+            klass.delete_all
+          rescue => e
+            puts e
+          end
+        else
+          puts "WARNING - Could not find AR model for class name #{k}"
+        end
+      end
+      
+      image_bank = 'public/spree/products'
+      
+      if(File.exists?(image_bank) )
+        puts "Removing old Product assets from '#{image_bank}'"
+        FileUtils::rm_rf(image_bank) 
+      end
+      
+      FileUtils::rm_rf('MissingRecords') if(File.exists?('MissingRecords') )
+      
+    end
+  
+  end
+end

data/lib/thor/spree/products_images.thor

@@ -0,0 +1,252 @@
+# Copyright:: (c) Autotelik Media Ltd 2012
+# Author ::   Tom Statter
+# Date ::     March 2012
+# License::   MIT. Free, Open Source.
+#
+# Usage::
+# bundle exec thor help datashift:spree
+# bundle exec thor datashift:spree:products -i db/datashift/MegamanFozz20111115_load.xls -s 299S_
+#
+# bundle exec thor  datashift:spree:images -i db/datashift/imagebank -s -p 299S_
+#
+
+# Note, not DataShift, case sensitive, create namespace for command line : datashift
+
+module Datashift
+      
+  class Spree < Thor     
+  
+    include DataShift::Logging
+       
+    desc "products", "Populate Spree Product/Variant data from .xls (Excel) or CSV file"
+     
+    method_option :input, :aliases => '-i', :required => true, :desc => "The import file (.xls or .csv)"
+    method_option :sku_prefix, :aliases => '-s', :desc => "Prefix to add to each SKU before saving Product"
+    method_option :verbose, :aliases => '-v', :type => :boolean, :desc => "Verbose logging"
+    method_option :config, :aliases => '-c',  :type => :string, :desc => "Configuration file containg defaults or over rides in YAML"
+    
+    def products()
+
+      # TODO - We're assuming run from a rails app/top level dir...
+      # ...can we make this more robust ? e.g what about when using active record but not in Rails app, 
+      require File.expand_path('config/environment.rb')
+      
+      input = options[:input]
+
+      require 'product_loader'
+
+      loader = DataShift::SpreeHelper::ProductLoader.new
+
+      # YAML configuration file to drive defaults etc
+
+      if(options[:config])
+        raise "Bad Config - Cannot find specified file #{options[:config]}" unless File.exists?(options[:config])
+        
+        loader.configure_from( options[:config] )
+      else
+        loader.set_default_value('available_on', Time.now.to_s(:db) )
+        loader.set_default_value('cost_price', 0.0 )
+        loader.set_default_value('price', 0.0 )
+      end
+      
+      loader.set_prefix('sku', options[:sku_prefix] ) if(options[:sku_prefix])
+      
+      puts "DataShift::Product starting upload from file: #{input}"
+
+      options = {:mandatory => ['sku', 'name', 'price']}
+    
+      # In >= 1.1.0 Image moved to master Variant from Product
+      options[:force_inclusion] = ['images'] if(DataShift::SpreeHelper::version.to_f > 1 )
+      
+      loader.perform_load(input, options)
+    end
+  
+
+    desc "attach_images", "Populate Products with images from Excel/CSV\nProvide column SKU or Name\nProvide column 'attachment' containing full path to image"
+    # :dummy => dummy run without actual saving to DB
+    method_option :input, :aliases => '-i', :required => true, :desc => "The 2 column import file (.xls or .csv)"
+    
+    def attach_images()
+
+      require File.expand_path('config/environment.rb')
+      
+      require 'image_loader'
+      
+      image_klazz = DataShift::SpreeHelper::get_spree_class('Image' )
+      
+      # force inclusion means add to operator list even if not present
+      options = { :force_inclusion => ['sku', 'attachment'] } if(SpreeHelper::version.to_f > 1 )
+    
+      loader = DataShift::SpreeHelper::ImageLoader.new(nil, options)
+    
+      loader.perform_load( options[:input], options )
+    end
+  
+    
+    #
+    # => thor datashift:spree:images input=vendor/extensions/site/fixtures/images
+    # => rake datashift:spree:images input=C:\images\photos large dummy=true
+    #
+    # => rake datashift:spree:images input=C:\images\taxon_icons skip_if_no_assoc=true klass=Taxon
+    #
+    desc "images", "Populate the DB with images from a directory\nwhere image names contain somewhere the Product Sku/Name"
+    
+    # :dummy => dummy run without actual saving to DB
+    method_option :input, :aliases => '-i', :required => true, :desc => "The input path containing images "
+    
+    method_option :glob, :aliases => '-g',  :desc => 'The glob to use to find files e.g. \'{*.jpg,*.gif,*.png}\' '
+    method_option :recursive, :aliases => '-r', :type => :boolean, :desc => "Scan sub directories of input for images"
+     
+    method_option :sku, :aliases => '-s', :desc => "Lookup Product based on image name starting with sku"
+    method_option :sku_prefix, :aliases => '-p', :desc => "SKU prefix to add to each image name before attempting Product lookup"
+    method_option :dummy, :aliases => '-d', :type => :boolean, :desc => "Dummy run, do not actually save Image or Product"
+    
+    method_option :process_when_no_assoc, :aliases => '-f', :type => :boolean, :desc => "Process image even if no Product found - force loading"
+    method_option :skip_when_assoc, :aliases => '-x', :type => :boolean, :desc => "DO not process image if Product already has image"
+    
+    method_option :verbose, :aliases => '-v', :type => :boolean, :desc => "Verbose logging"
+    method_option :config, :aliases => '-c',  :type => :string, :desc => "Configuration file for Image Loader in YAML"
+    method_option :split_file_name_on,  :type => :string, :desc => "delimiter to progressivley split filename for Prod lookup", :default => '_'
+    method_option :case_sensitive, :type => :boolean, :desc => "Use case sensitive where clause to find Product"
+    method_option :use_like, :type => :boolean, :desc => "Use sku/name LIKE 'string%' instead of sku/name = 'string' in where clauses to find Product"
+  
+    def images()
+
+      require File.expand_path('config/environment.rb')
+      
+      require 'spree/image_loader'
+            
+      @verbose = options[:verbose]
+       
+      puts "Using Product Name for lookup" unless(options[:sku])
+      puts "Using SKU for lookup" if(options[:sku])
+       
+      image_klazz = DataShift::SpreeHelper::get_spree_class('Image' )
+       
+      attachment_klazz  = DataShift::SpreeHelper::get_spree_class('Product' )
+      attachment_field  = 'name'
+
+      if(options[:sku] || SpreeHelper::version.to_f > 1)
+        attachment_klazz =  DataShift::SpreeHelper::get_spree_class('Variant' ) 
+        attachment_field = 'sku'
+      end
+
+      image_loader = DataShift::SpreeHelper::ImageLoader.new(nil, options)
+ 
+      if(options[:config])
+        raise "Bad Config - Cannot find specified file #{options[:config]}" unless File.exists?(options[:config])
+        
+        image_loader.configure_from( options[:config] )
+      end
+
+      loader_config = image_loader.options
+ 
+      puts "CONFIG: #{loader_config.inspect}"
+      puts "OPTIONS #{options.inspect}"
+      
+      @image_path = options[:input]
+      
+      unless(File.exists?(@image_path))
+        puts "ERROR: Supplied Path [#{@image_path}] not accesible"
+        exit(-1)
+      end
+      
+      logger.info "Loading Spree images from #{@image_path}"
+
+      missing_records = []
+         
+      # try splitting up filename in various ways looking for the SKU
+      split_on = loader_config['split_file_name_on'] || options[:split_file_name_on]
+             
+      image_cache = DataShift::ImageLoading::get_files(@image_path, options)
+      
+      puts "Found #{image_cache.size} image files - splitting names on delimiter : #{split_on}"
+         
+      image_cache.each do |image_name|
+
+        image_base_name = File.basename(image_name)
+
+        logger.info "Processing image file #{image_base_name} "
+          
+        base_name = File.basename(image_name, '.*')
+        base_name.strip!
+            
+        record = nil
+                   
+        record = image_loader.get_record_by(attachment_klazz, attachment_field, base_name)
+         
+        # TODO move into the ImageLoading module 
+        # 
+        # try the seperate individual portions of the filename, front -> back
+        base_name.split(split_on).each do |x|
+          x = "#{options[:sku_prefix]}#{x}" if(options[:sku_prefix])
+         
+          record = image_loader.get_record_by(attachment_klazz, attachment_field, x)
+          break if record
+        end unless(record)
+            
+        # this time try sequentially and incrementally scanning
+        base_name.split(split_on).inject("") do |str, x|
+          z = (options[:sku_prefix]) ? "#{options[:sku_prefix]}#{str}#{x}": "#{str}#{x}"
+          puts z
+          record = image_loader.get_record_by(attachment_klazz, attachment_field, z)
+          break if record
+          x
+        end unless(record)
+        
+        # END TODO
+          
+        record = record.product if(record && record.respond_to?(:product))  # SKU stored on Variant but we want it's master Product
+      
+        if(record)
+          logger.info "Found record for attachment : #{record.inspect}"
+    
+          if(options[:skip_when_assoc])
+            
+            paper_clip_name = image_base_name.gsub(Paperclip::Attachment::default_options[:restricted_characters], '_')
+            
+            exists = record.images.detect {|i| puts "Check #{paper_clip_name} matches #{i.attachment_file_name}"; i.attachment_file_name == paper_clip_name }
+            if(exists)
+              rid = record.respond_to?(:name) ? record.name : record.id
+              puts "Skipping Image #{image_name} already loaded for #{rid}"
+              logger.info "Skipping - Image #{image_name} already loaded for #{attachment_klazz}"
+              next 
+            end
+          end
+        else
+          missing_records << image_name
+        end
+          
+        next if(options[:dummy]) # Don't actually create/upload to DB if we are doing dummy run
+
+        # Check if Image must have an associated record
+        if(record || (record.nil? && options[:process_when_no_assoc]))
+          image_loader.reset()
+          
+          logger.info("Adding Image #{image_name} to Product #{record.name}")
+          image_loader.create_image(image_klazz, image_name, record)
+          puts "Added Image #{File.basename(image_name)} to Product #{record.sku} : #{record.name}" if(@verbose)
+        end
+
+      end
+
+      unless missing_records.empty?
+        FileUtils.mkdir_p('MissingRecords') unless File.directory?('MissingRecords')
+        
+        puts "WARNING : #{missing_records.size} of #{image_cache.size} images could not be attached to a Product"
+        puts 'For your convenience a copy of images with MISSING Products will be saved to :  ./MissingRecords'
+        missing_records.each do |i|
+          puts "Copying #{i} to MissingRecords folder" if(options[:verbose])
+          FileUtils.cp( i, 'MissingRecords')  unless(options[:dummy] == 'true')
+        end
+      else
+        puts "All images (#{image_cache.size}) were succesfully attached to a Product"
+      end
+
+      puts "Dummy Run Complete- if happy run without -d" if(options[:dummy])
+   
+    end
+   
+  end
+
+end