mercator_legacy_importer 0.0.1 → 0.1

data/lib/tasks/countries.rake

@@ -1,14 +1,20 @@
-def import_countries
-  puts "\n\nCountries:"
+# encoding: utf-8
 
-  Legacy::Country.all.each do |legacy_country|
-    country = Country.find_or_initialize_by_name_de(legacy_country.country_name)
-    if country.update_attributes(name_en: legacy_country.country_name,
-                                 code: legacy_country.country_a2,
-                                 legacy_id: legacy_country.id)
-      print "C"
-    else
-      puts "\nFAILURE: Country: " + country.errors.first.to_s
+namespace :legacy_import do
+  # starten als: 'bundle exec rake legacy_import:countries
+  # in Produktivumgebungen: 'bundle exec rake legacy_import:countries RAILS_ENV=production'
+  desc "Import countries from legacy webshop"
+  task :countries => :environment do
+
+    MercatorLegacyImporter::Country.all.each do |legacy_country|
+      country = Country.find_or_initialize_by_name_de(legacy_country.country_name)
+      if country.update_attributes(name_en: legacy_country.country_name,
+                                   code: legacy_country.country_a2,
+                                   legacy_id: legacy_country.id)
+        print "C"
+      else
+        puts "\nFAILURE: Country: " + country.errors.first.to_s
+      end
     end
   end
 end

data/lib/tasks/features.rake

@@ -1,21 +1,29 @@
-def import_features
-  puts "\n\nFeatures:"
+# encoding: utf-8
 
-  n=1
-  Legacy::ProductOverviewProperty.all.each do |legacy_product_overview_property|
-    legacy_product = Product.find_by_legacy_id(legacy_product_overview_property.product_id)
-    unless legacy_product
-      puts "\nFAILURE: Product not found: " + legacy_product_overview_property.product_id.to_s
-      next
-    end
-    feature = Feature.create(text_de: legacy_product_overview_property.description,
-                             position: ( legacy_product_overview_property.order || n = n + 1 ),
-                             product_id: legacy_product.id,
-                             legacy_id: legacy_product_overview_property.id)
-    if feature.save
-      print "F"
-    else
-      puts "\nFAILURE: Feature: " + feature.errors.first.to_s
+namespace :legacy_import do
+  # starten als: 'bundle exec rake legacy_import:features
+  # in Produktivumgebungen: 'bundle exec rake legacy_import:features RAILS_ENV=production'
+  desc "Import features from legacy webshop"
+  task :features => :environment do
+
+    puts "\n\nFeatures:"
+
+    n=1
+    MercatorLegacyImporter::ProductOverviewProperty.all.each do |legacy_product_overview_property|
+      legacy_product = Product.find_by_legacy_id(legacy_product_overview_property.product_id)
+      unless legacy_product
+        puts "\nFAILURE: Product not found: " + legacy_product_overview_property.product_id.to_s
+        next
+      end
+      feature = Feature.create(text_de: legacy_product_overview_property.description,
+                               position: ( legacy_product_overview_property.order || n = n + 1 ),
+                               product_id: legacy_product.id,
+                               legacy_id: legacy_product_overview_property.id)
+      if feature.save
+        print "F"
+      else
+        puts "\nFAILURE: Feature: " + feature.errors.first.to_s
+      end
     end
   end
 end

data/lib/tasks/page_template.rake

@@ -1,13 +1,20 @@
-def import_page_templates
-  puts "\n\nPage Templates:"
+# encoding: utf-8
 
-  Legacy::PageTemplate.all.each do |legacy_page_template|
-    if page_template = PageTemplate.create(name: legacy_page_template.name,
-                                           content: legacy_page_template.content,
-                                           legacy_id: legacy_page_template.id) 
-      print "T"
-    else
-      puts "\nFAILURE: PageTemplate: " + page_template.errors.first.to_s
+namespace :legacy_import do
+  # starten als: 'bundle exec rake legacy_import:page_templates
+  # in Produktivumgebungen: 'bundle exec rake legacy_import:page_templates RAILS_ENV=production'
+  desc "Import page_templates from legacy webshop"
+  task :page_templates => :environment do
+    puts "\n\nPage Templates:"
+
+    MercatorLegacyImporter::PageTemplate.all.each do |legacy_page_template|
+      if page_template = PageTemplate.create(name: legacy_page_template.name,
+                                             content: legacy_page_template.content,
+                                             legacy_id: legacy_page_template.id)
+        print "T"
+      else
+        puts "\nFAILURE: PageTemplate: " + page_template.errors.first.to_s
+      end
     end
   end
 end

data/lib/tasks/product_images.rake

@@ -1,11 +1,27 @@
-def import_product_images
-  require 'net/http'
-  puts "\n\nProduct Images:"
+# encoding: utf-8
+
+namespace :legacy_import do
+  # starten als: 'bundle exec rake legacy_import:product_images
+  # in Produktivumgebungen: 'bundle exec rake legacy_import:product_images RAILS_ENV=production'
+  desc "Import product_images from legacy webshop"
+  task :product_images => :environment do
+
+    require 'net/http'
+    puts "\n\nProduct Images:"
+
+    Net::HTTP.start("www.iv-shop.at") do |http|
+      MercatorLegacyImporter::Product.all.each do |legacy_product|
+        unless legacy_product.image_file_name || legacy_product.overview_file_name
+          print "x"
+          next
+        end
 
-  Net::HTTP.start("www.iv-shop.at") do |http|
-    Legacy::Product.all.each do |legacy_product|
-      if legacy_product.image_file_name || legacy_product.overview_file_name
         product = Product.find_by_legacy_id(legacy_product.id)
+        if product.photo_file_name.present?
+          print "✔"
+          next
+        end
+
         filename = "/system/images/" + legacy_product.id.to_s +
                             "/original/" + legacy_product.image_file_name.presence ||
                                            legacy_product.overview_file_name
@@ -13,13 +29,14 @@ def import_product_images
         data.class.class_eval { attr_accessor :original_filename }
         data.original_filename = legacy_product.image_file_name.presence || legacy_product.overview_file_name
         product.photo = data
+        product.photo_content_type = MIME::Types.type_for(data.original_filename).first.content_type
+
         if product.save
           print "P"
         else
           puts "\nFAILURE: Image: " + product.errors.first.to_s
+          # If image is missing on server, we get probable a content type mismatch error, e.g. html (error page) instead of png (image)
         end
-      else
-        print "."
       end
     end
   end

data/lib/tasks/product_relations.rake

@@ -1,21 +1,29 @@
-def import_product_relations
-  puts "\n\nProductRelations:"
+# encoding: utf-8
 
-  Legacy::ProductRelation.all.each do |legacy_product_relation|
-    if product = Product.find_by(legacy_id: legacy_product_relation.product_id)
-      if related_product = Product.find_by(legacy_id: legacy_product_relation.related_product_id)
+namespace :legacy_import do
+  # starten als: 'bundle exec rake legacy_import:product_relations
+  # in Produktivumgebungen: 'bundle exec rake legacy_import:product_relations RAILS_ENV=production'
+  desc "Import product relations from legacy webshop"
+  task :product_relations => :environment do
 
-        if productrelation = Productrelation.create(product_id: product.id, 
-                                                 related_product_id: related_product.id)
-          print "P"
+    puts "\n\nProductRelations:"
+
+    MercatorLegacyImporter::ProductRelation.all.each do |legacy_product_relation|
+      if product = Product.find_by(legacy_id: legacy_product_relation.product_id)
+        if related_product = Product.find_by(legacy_id: legacy_product_relation.related_product_id)
+
+          if productrelation = Productrelation.create(product_id: product.id,
+                                                   related_product_id: related_product.id)
+            print "P"
+          else
+            puts "\nFAILURE: Productrelation: " + productrelation.errors.first.to_s
+          end
         else
-          puts "\nFAILURE: Productrelation: " + productrelation.errors.first.to_s
+          puts "\n FAIILURE: Product not found"
         end
-      else 
-        puts "\n FAIILURE: Product not found"
+      else
+          puts "\n FAIILURE: RelatedProduct not found"
       end
-    else
-        puts "\n FAIILURE: RelatedProduct not found"
     end
   end
 end

data/lib/tasks/products.rake

@@ -1,48 +1,61 @@
-def import_products
-  puts "\n\nProducts:"
-  Product.all.each do |product|
-    product.delete
-  end
-  print "Products deleted."
-
-  Legacy::Product.all.each do |legacy_product|
-    legacy_product_de = legacy_product.product_translations.german.first
-    legacy_product_en = legacy_product.product_translations.english.first
+# encoding: utf-8
+require 'string_extensions'
 
-    if legacy_product_de && legacy_product_de.title.present?
-      name_de = legacy_product_de.title
-    else
-      name_de = legacy_product.name
+namespace :legacy_import do
+  # starten als: 'bundle exec rake legacy_import:products
+  # in Produktivumgebungen: 'bundle exec rake legacy_import:products RAILS_ENV=production'
+  desc "Import products from legacy webshop"
+  task :products => :environment do
+    puts "\n\nProducts:"
+    Product.all.each do |product|
+      product.delete
     end
+    print "Products deleted."
 
-    if legacy_product_de && legacy_product_de.long_description.present?
-      description_de = legacy_product_de.long_description
-    else
-      description_de = "fehlt"
-    end
+    MercatorLegacyImporter::Product.all.each do |legacy_product|
+      legacy_product_de = legacy_product.product_translations.german.first
+      legacy_product_en = legacy_product.product_translations.english.first
 
-    if legacy_product_en && legacy_product_en.title.present?
-      name_en = legacy_product_en.title
-    else
-      name_en = legacy_product.name
-    end
+      if legacy_product_de && legacy_product_de.title.present?
+        title_de = legacy_product_de.title
+      else
+        title_de = legacy_product.name
+      end
 
-    if legacy_product_en && legacy_product_en.long_description.present?
-      description_en = legacy_product_en.long_description
-    else
-      description_en = "missing"
-    end
+      if legacy_product_de && legacy_product_de.long_description.present?
+        description_de = legacy_product_de.long_description
+      else
+        description_de = "fehlt"
+      end
+
+      if legacy_product_en && legacy_product_en.title.present?
+        title_en = legacy_product_en.title
+      else
+        title_en = legacy_product.name
+      end
+
+      if legacy_product_en && legacy_product_en.long_description.present?
+        description_en = legacy_product_en.long_description
+      else
+        description_en = "missing"
+      end
 
-    product = Product.create(number: legacy_product.article_number,
-                             name_de: name_de,
-                             name_en: name_en,
-                             description_de: description_de,
-                             description_en: description_en,
-                             legacy_id: legacy_product.id)
-    if product.save
-      print "P"
-    else
-      puts "\nFAILURE: Product: " + product.errors.first.to_s
+      product = Product.create(number: legacy_product.article_number,
+                               title_de: title_de,
+                               title_en: title_en,
+                               description_de: description_de.fix_utf8,
+                               description_en: description_en.fix_utf8,
+                               legacy_id: legacy_product.id)
+      if product.save
+        print "P"
+      else
+        product.number = legacy_product.id.to_s + " - Duplikat von " + legacy_product.article_number
+        if product.save
+          print "P"
+        else
+          puts "\nFAILURE: Product " + legacy_product.article_number + ": " + product.errors.first.to_s
+        end
+      end
     end
   end
 end

data/lib/tasks/properties.rake

@@ -1,44 +1,53 @@
-def import_properties
-#  puts "\n\nProperty Groups and Properties:"
-#  Property.all.each do |property|
-#    property.delete
-#  end
-#  print "Properties deleted."
-#  PropertyGroup.all.each do |property_group|
-#    property_group.delete
-#  end
-#  print "Property Groups deleted."
+# encoding: utf-8
 
-  Legacy::Product.all.each do |legacy_product|
-    product = Product.find_by_legacy_id(legacy_product.id)
-    legacy_product.properties.each do |legacy_property|
-      # next if legacy_property.id < 21050
-      legacy_property_de = legacy_property.property_translations.german.first
-      legacy_property_en = legacy_property.property_translations.english.first
+namespace :legacy_import do
+  # starten als: 'bundle exec rake legacy_import:properties
+  # in Produktivumgebungen: 'bundle exec rake legacy_import:properties RAILS_ENV=production'
+  desc "Import properties from legacy webshop"
+  task :properties => :environment do
 
-      property_group =
-        PropertyGroup.find_or_initialize_by_name_de_and_product_id(
-          legacy_property_de.group.presence || legacy_property_de.name,
-                                                                   product.id)
-      if property_group.update_attributes(name_en: legacy_property_en.group.presence ||
-                                                   legacy_property_en.name,
-                                          position: 1)
-        print "G"
+    puts "\n\nProperty Groups and Properties:"
+    Property.all.each do |property|
+      property.delete
+    end
+
+    print "Properties deleted."
+    PropertyGroup.all.each do |property_group|
+      property_group.delete
+    end
+    print "Property Groups deleted."
+
+    MercatorLegacyImporter::Product.all.each do |legacy_product|
+      product = Product.find_by_legacy_id(legacy_product.id)
+      legacy_product.properties.each do |legacy_property|
+        # next if legacy_property.id < 21050
+        legacy_property_de = legacy_property.property_translations.german.first
+        legacy_property_en = legacy_property.property_translations.english.first
+
+        property_group =
+          PropertyGroup.find_or_initialize_by_name_de_and_product_id(
+            legacy_property_de.group.presence || legacy_property_de.name,
+                                                                     product.id)
+        if property_group.update_attributes(name_en: legacy_property_en.group.presence ||
+                                                     legacy_property_en.name,
+                                            position: 1)
+          print "G"
 
-        property = Property.create(name_de: legacy_property_de.name,
-                                   property_group_id: property_group.id,
-                                   name_en: legacy_property_en.name,
-                                   description_de: legacy_property.presentation_value,
-                                   description_en: legacy_property.presentation_value,
-                                   position: 1,
-                                   legacy_id: legacy_property.id)
-        if property.save
-          print "p"
+          property = Property.create(name_de: legacy_property_de.name,
+                                     property_group_id: property_group.id,
+                                     name_en: legacy_property_en.name,
+                                     description_de: legacy_property.presentation_value,
+                                     description_en: legacy_property.presentation_value,
+                                     position: 1,
+                                     legacy_id: legacy_property.id)
+          if property.save
+            print "p"
+          else
+            puts "\nFAILURE: Property: " + property.errors.first.to_s
+          end
         else
-          puts "\nFAILURE: Property: " + property.errors.first.to_s
+          puts "\nFAILURE: PropertyGroup: " + property_group.errors.first.to_s
         end
-      else
-        puts "\nFAILURE: PropertyGroup: " + property_group.errors.first.to_s
       end
     end
   end

data/lib/tasks/recommendations.rake

@@ -1,28 +1,39 @@
-def import_recommendations
-  puts "\n\nRecommendations:"
+# encoding: utf-8
 
-  Legacy::Recommendation.all.each do |legacy_recommendation|
-    legacy_reason_de = legacy_recommendation.recommendation_translations.german.first
-    legacy_reason_en = legacy_recommendation.recommendation_translations.english.first
+namespace :legacy_import do
+  # starten als: 'bundle exec rake legacy_import:recommendations
+  # in Produktivumgebungen: 'bundle exec rake legacy_import:recommendations RAILS_ENV=production'
+  desc "Import recommendations from legacy webshop"
+  task :recommendations => :environment do
+    puts "\n\nRecommendations:"
 
-    next if legacy_recommendation.from_product_id.nil?
-    if product = Product.find_by(legacy_id: legacy_recommendation.from_product_id)
-      next if legacy_recommendation.for_product_id.blank?
-      if recommendation = Product.find_by(number: legacy_recommendation.for_product_id)
+    Recommendation.all.each do |recommendation|
+      recommendation.delete
+    end
+    print "Recommendations deleted."
+
+    MercatorLegacyImporter::Recommendation.all.each do |legacy_recommendation|
+      legacy_reason_de = legacy_recommendation.recommendation_translations.german.first
+      legacy_reason_en = legacy_recommendation.recommendation_translations.english.first
 
-        if recommendation = Recommendation.create(product_id: product.id, 
-                                                  recommended_product_id: recommendation.id,
-                                                  reason_de: legacy_reason_de.description,
-                                                  reason_en: legacy_reason_en.description)
-          print "R"
+      next if legacy_recommendation.from_product_id.nil?
+      if product = Product.find_by(legacy_id: legacy_recommendation.from_product_id)
+        next if legacy_recommendation.for_product_id.blank?
+        if recommendation = Product.find_by(number: legacy_recommendation.for_product_id)
+          if recommendation = Recommendation.create(product_id: product.id,
+                                                    recommended_product_id: recommendation.id,
+                                                    reason_de: legacy_reason_de.description.fix_utf8,
+                                                    reason_en: legacy_reason_en.description.fix_utf8)
+            print "R"
+          else
+            puts "\nFAILURE: Recommendation: " + recommendation.errors.first.to_s
+          end
         else
-          puts "\nFAILURE: Recommendation: " + recommendation.errors.first.to_s
+          puts "\n FAIILURE: Recommended product not found: " + legacy_recommendation.for_product_id
         end
-      else 
-        puts "\n FAIILURE: Recommended product not found: " + legacy_recommendation.for_product_id
+      else
+        puts "\n FAIILURE: Product not found: " + legacy_recommendation.from_product_id.to_s
       end
-    else
-      puts "\n FAIILURE: Product not found: " + legacy_recommendation.from_product_id.to_s
     end
   end
 end