goldencobra 1.4.27 → 2.3.3

data/app/models/goldencobra/article_concerns/meta_tag.rb

@@ -0,0 +1,104 @@
+
+# Meta Tags fuer einen Goldencobra::Article
+#
+# Ueber diese Methoden kann einheitlich auf die Metatags zugegriffen werden.
+# Die Regeln zur Erstellung der MetaTags und deren Fallbacks koennen so zentral
+# gesteuert werden
+#
+module Goldencobra::ArticleConcerns::MetaTag
+  extend ActiveSupport::Concern
+
+  def meta_tag_site
+    Goldencobra::Setting.for_key("goldencobra.page.default_title_tag")
+  end
+
+  def meta_tag_title_tag
+    get_meta_value(:metatag_title_tag, :breadcrumb)
+  end
+
+  def meta_tag_meta_description
+    get_meta_value(:metatag_meta_description, :teaser)
+  end
+
+  def meta_tag_open_graph_title
+    get_meta_value(:metatag_open_graph_title, :metatag_title_tag, :breadcrumb, :title)
+  end
+
+  def meta_tag_open_graph_description
+    get_meta_value(:metatag_open_graph_description, :metatag_meta_description, :teaser)
+  end
+
+  def meta_tag_open_graph_type
+    metatag_open_graph_type.present? ? metatag_open_graph_type : "website"
+  end
+
+  def meta_tag_open_graph_url
+    get_meta_value(:metatag_open_graph_url, :absolute_public_url)
+  end
+
+  def meta_tag_open_graph_image
+    if metatag_open_graph_image.present?
+      og_image_url = metatag_open_graph_image
+    else
+      og_image_url = images.first.try(:image).try(:url)
+    end
+    og_image_fallback = Goldencobra::Setting.for_key("goldencobra.facebook.opengraph_default_image")
+    og_image_url.present? ? og_image_url : og_image_fallback
+  end
+
+  def meta_tag_canonical_url
+    get_meta_value(:canonical_url, :absolute_public_url)
+  end
+
+  # Generate a hash of custom_tags in settings
+  # every children in goldencobra.page.custom_tags will by a custom meta_tag.
+  # Esisting tags (canonical, noindex,... ) will be overwritten by custom tags
+  # with the same name
+  #
+  # @return [Hash] {author: "MyValue", custom_tag: "otherValue"}
+  def meta_tag_static_custom
+    custom_tag_settings = Goldencobra::Setting.where(title: "custom_tags").first
+    return {} if custom_tag_settings.blank?
+    if custom_tag_settings.present? && custom_tag_settings.parent_names == "goldencobra.page"
+      Hash[custom_tag_settings.children.map { |s| [s.title.to_sym, s.value] }]
+    end
+  end
+
+  def combined_meta_tags
+    {
+      site: meta_tag_site,
+      title: meta_tag_title_tag,
+      separator: " ",
+      reverse: true,
+      description: meta_tag_meta_description,
+      canonical: meta_tag_canonical_url,
+      open_graph: combined_open_graph_tags,
+      noindex: robots_no_index
+    }.merge(meta_tag_static_custom)
+  end
+
+  def combined_open_graph_tags
+    {
+      title: meta_tag_open_graph_title,
+      description: meta_tag_open_graph_description,
+      type: meta_tag_open_graph_type,
+      url: meta_tag_open_graph_url,
+      image: meta_tag_open_graph_image
+    }
+  end
+
+  private
+
+  # get first present Value
+  # calls al list of methods given as Array on the current article.
+  # The first method with anpresent value will be returned
+  #
+  # @return [String] Response of called Method (mostly Strings)
+  def get_meta_value(*method_names_to_call)
+    method_names_to_call.map do |single_meta_method|
+      next unless send(single_meta_method).present?
+      return send(single_meta_method)
+    end
+    nil
+  end
+end

data/app/models/goldencobra/article_image.rb

@@ -15,9 +15,9 @@
 module Goldencobra
   class ArticleImage < ActiveRecord::Base
     belongs_to :article
-    belongs_to :image, :class_name => Goldencobra::Upload, :foreign_key => "image_id"
+    belongs_to :image, class_name: Goldencobra::Upload, foreign_key: "image_id"
 
-    accepts_nested_attributes_for :image, :allow_destroy => true
+    accepts_nested_attributes_for :image, allow_destroy: true
 
   end
 end

data/app/models/goldencobra/article_url.rb

@@ -0,0 +1,54 @@
+module Goldencobra
+  class ArticleUrl < ActiveRecord::Base
+    belongs_to :article, class_name: Goldencobra::Article
+    web_url :url
+
+    validates :article_id, presence: true
+    validates :url, presence: true, uniqueness: { case_sensitive: false }
+
+    def self.recreate_all_urls
+      Goldencobra::ArticleUrl.all.each do |goldencobra_article_url|
+        goldencobra_article_url.destroy
+        goldencobra_article_url.article.save
+      end
+    end
+
+    def self.setup(article_id)
+      article = Goldencobra::Article.find_by_id(article_id)
+
+      # if an article is deleted, related has_many :urls should be deleted to by definition,
+      # so there is nothing else to do
+      return true unless article
+
+      # are multiple domains in use?
+      if Goldencobra::Domain.any?
+        setup_domain_urls(article)
+      else
+        setup_single_url(article)
+      end
+
+      article.descendant_ids.each do |did|
+        Goldencobra::ArticleUrl.setup(did)
+      end
+    end
+
+    def self.setup_domain_urls(article)
+      # cleanup old Domain Urls
+      Goldencobra::ArticleUrl.where(article_id: article.id).destroy_all
+      protocol = Goldencobra::Url.protocol
+
+      Goldencobra::Domain.all.each do |domain|
+        new_url = "#{protocol}://#{domain.hostname}#{domain.url_prefix}#{article.public_url}"
+        Goldencobra::ArticleUrl.create(article_id: article.id, url: new_url)
+      end
+    end
+
+    def self.setup_single_url(article)
+      article_url = Goldencobra::ArticleUrl.where(article_id: article.id).first_or_create
+      if article_url.url != article.absolute_public_url.downcase
+        article_url.url = article.absolute_public_url.downcase
+        article_url.save
+      end
+    end
+  end
+end

data/app/models/goldencobra/articletype.rb

@@ -1,56 +1,117 @@
-# encoding: utf-8
-
 module Goldencobra
   class Articletype < ActiveRecord::Base
     attr_accessible :default_template_file, :name, :fieldgroups_attributes
-    has_many :articles, :class_name => Goldencobra::Article, :foreign_key => :article_type, :primary_key => :name
+
+    has_many :articles, class_name: Goldencobra::Article, foreign_key: :article_type, primary_key: :name
+    has_many :fieldgroups, class_name: Goldencobra::ArticletypeGroup, dependent: :destroy
+
+    accepts_nested_attributes_for :fieldgroups, allow_destroy: true
+
     validates_uniqueness_of :name
 
-    has_many :fieldgroups, :class_name => Goldencobra::ArticletypeGroup, :dependent => :destroy
-    accepts_nested_attributes_for :fieldgroups, :allow_destroy => true
-
-    ArticleFieldOptions = {
-        :global_sorting_id => %{<% f.input :global_sorting_id, :hint => I18n.t("goldencobra.article_field_hints.global_sorting_id") %>},
-        :title => %{<% f.input :title, :hint => I18n.t("goldencobra.article_field_hints.title") %>},
-        :subtitle => %{<% f.input :subtitle %>},
-        :content => %{<% f.input :content, :input_html => { :class => "tinymce" } %>},
-        :teaser => %{<% f.input :teaser, :hint => I18n.t("goldencobra.article_field_hints.teaser"), :input_html => { :rows => 5 } %>},
-        :summary => %{<% f.input :summary, :hint => I18n.t("goldencobra.article_field_hints.summary"), :input_html => { :rows => 5 } %>},
-        :tag_list => %{<% f.input :tag_list, :hint => I18n.t("goldencobra.article_field_hints.tag_list"), :wrapper_html => { class: '' } %>},
-        :frontend_tag_list => %{<% f.input :frontend_tag_list, hint: I18n.t("goldencobra.article_field_hints.frontend_tag_list"), :wrapper_html => { class: '' } %>},
-        :active => %{<% f.input :active, :hint => I18n.t("goldencobra.article_field_hints.active"), :wrapper_html => { class: '' } %>},
-        :active_since => %{<% f.input :active_since, :hint => I18n.t("goldencobra.article_field_hints.active_since"), as: :string, :input_html => { class: "", :size => "20" }, :wrapper_html => { class: 'expert' } %>},
-        :context_info => %{<% f.input :context_info, :input_html => { :class => "tinymce" }, :hint => I18n.t("goldencobra.article_field_hints.context_info") %>},
-        :metatags => %{<% f.has_many :metatags do |m|
-          m.input :name, :as => :select, :collection => Goldencobra::Article::MetatagNames, :input_html => { :class => 'metatag_names'}, :hint => I18n.t("goldencobra.article_field_hints.metatags_name")
-          m.input :value, :input_html => { :class => 'metatag_values'}
-          m.input :_destroy, :label => "entfernen/zurücksetzen", :hint => I18n.t("goldencobra.article_field_hints.metatags_destroy"), :as => :boolean
-        end %>},
-        :breadcrumb => %{<% f.input :breadcrumb, :hint => I18n.t("goldencobra.article_field_hints.breadcrumb") %>},
-        :url_name => %{<% f.input :url_name, :hint => I18n.t("goldencobra.article_field_hints.url_name"), required: false %>},
-        :parent_id => %{<% f.input :parent_id, :hint => I18n.t("goldencobra.article_field_hints.parent_id"), :as => :select, :collection => Goldencobra::Article.where("id = ?", f.object.parent_id).select([:id,:title, :ancestry]).map{|c| [c.parent_path, c.id]}.sort{|a,b| a[0] <=> b[0]}, :include_blank => true, :input_html => { :class => 'chzn-select-deselect get_goldencobra_articles_per_remote', :style => 'width: 70%;', 'data-placeholder' => 'Elternelement auswählen' } %>},
-        :canonical_url => %{<% f.input :canonical_url, :hint => I18n.t("goldencobra.article_field_hints.canonical_url") %>},
-        :enable_social_sharing => %{<% f.input :enable_social_sharing, :hint => I18n.t("goldencobra.article_field_hints.enable_social_sharing") %>},
-        :robots_no_index => %{<% f.input :robots_no_index, :hint => I18n.t("goldencobra.article_field_hints.robots_no_index") %>},
-        :cacheable => %{<% f.input :cacheable, :as => :boolean, :hint => I18n.t("goldencobra.article_field_hints.cacheable") %>},
-        :commentable => %{<% f.input :commentable, :as => :boolean, :hint => I18n.t("goldencobra.article_field_hints.commentable") %>},
-        :dynamic_redirection => %{<% f.input :dynamic_redirection, :as => :select, :collection => Goldencobra::Article::DynamicRedirectOptions.map{|a| [a[1], a[0]]}, :include_blank => false %>},
-        :external_url_redirect => %{<% f.input :external_url_redirect %>},
-        :redirect_link_title => %{<% f.input :redirect_link_title %>},
-        :redirection_target_in_new_window => %{<% f.input :redirection_target_in_new_window %>},
-        :author => %{<% f.input :authors, :as => :select, :collection => Goldencobra::Author.order("lastname ASC").map{ |a| [a.lastname.to_s + ", " + a.firstname.to_s, a.id] }, :input_html => { :class => "chzn-select", :style => "width: 70%;", "data-placeholder" => I18n.t("goldencobra.article_field_placeholder.author") }, :hint => I18n.t("goldencobra.article_field_hints.author") %>},
-        :permissions => %{<% f.has_many :permissions do |p|
-          p.input :domain, :include_blank => "Alle"
-          p.input :role, :include_blank => "Alle"
-          p.input :action, :as => :select, :collection => Goldencobra::Permission::PossibleActions, :include_blank => false
-          p.input :_destroy, :as => :boolean
-        end %>},
-        :article_images => %{<% f.has_many :article_images do |ai|
-          ai.input :image, :as => :select, :collection => Goldencobra::Upload.order("updated_at DESC").map{|c| [c.complete_list_name, c.id]}, :input_html => { :class => 'article_image_file chzn-select', :style => 'width: 70%;', 'data-placeholder' => 'Medium auswählen' }, :label => "Medium wählen"
-          ai.input :position, :as => :select, :collection => Goldencobra::Setting.for_key("goldencobra.article.image_positions").to_s.split(",").map(&:strip), :include_blank => false
-          ai.input :_destroy, :as => :boolean
-        end %>}
-    }
+    after_destroy :set_defaults
+
+    ArticleFieldOptions = [
+      :global_sorting_id, :title, :subtitle, :content,
+      :teaser, :summary, :tag_list, :frontend_tag_list, :active,
+      :active_since, :context_info, :metatags, :metatag_title_tag,
+      :metatag_meta_description, :metatag_open_graph_title,
+      :metatag_open_graph_description, :metatag_open_graph_type,
+      :metatag_open_graph_url, :metatag_open_graph_image, :breadcrumb,
+      :url_name, :parent_id, :canonical_url, :enable_social_sharing,
+      :robots_no_index, :cacheable, :commentable, :dynamic_redirection,
+      :external_url_redirect, :redirect_link_title, :redirection_target_in_new_window,
+      :author, :permissions, :widgets, :article_images, :index__display_index_articles,
+      :index__article_for_index_id, :index__article_descendents_depth,
+      :index__display_index_types, :index__display_index_articletypes,
+      :index__index_of_articles_tagged_with, :index__not_tagged_with, :index__sorter_limit,
+      :index__sort_order, :index__reverse_sort, :state, :creator
+    ]
+
+    def set_defaults
+      Goldencobra::Articletype.reset_to_default
+    end
+
+    def self.reset_to_default
+      if ActiveRecord::Base.connection.table_exists?("goldencobra_articles") &&
+         ActiveRecord::Base.connection.table_exists?("goldencobra_articletypes")
+        Goldencobra::Article.article_types_for_select.each do |at|
+          if Goldencobra::Articletype.find_by_name(at).blank?
+            Goldencobra::Articletype.create(name: at, default_template_file: "application")
+          end
+        end
+
+        if ActiveRecord::Base.connection.table_exists?("goldencobra_articletype_groups")
+          Goldencobra::Articletype.all.each do |at|
+            # Install basic set of fieldgroups and fields if none are set up
+            reset_field_blocks_for(at)
+          end
+        end
+      end
+    end
+
+    private
+
+
+    def self.reset_field_blocks_for(articletype)
+      if articletype.try(:fieldgroups).blank?
+        reset_common_block(articletype)
+        reset_index_block(articletype)
+        reset_media_block(articletype)
+        reset_meta_block(articletype)
+        reset_widget_block(articletype)
+        reset_settings_block(articletype)
+      end
+    end
+
+    def self.reset_common_block(at)
+      new_a = at.fieldgroups.create(title: "Allgemein", position: "first_block", foldable: true, closed: false, expert: false, sorter: 1)
+      common_elements = ["active", "subtitle", "title", "teaser", "content", "tag_list"]
+      common_elements.each_with_index do |name, index|
+        new_a.fields.create(fieldname: name, sorter: index * 10)
+      end
+    end
+
+    def self.reset_index_block(at)
+      if at.name.include?(" Index")
+        new_a = at.fieldgroups.create(title: "Index", position: "first_block", foldable: true, closed: false, expert: false, sorter: 2)
+        index_elements = ["index__display_index_articles", "index__article_for_index_id", "index__article_descendents_depth",
+                          "index__display_index_types", "index__display_index_articletypes", "index__index_of_articles_tagged_with",
+                          "index__not_tagged_with", "index__sorter_limit","index__sort_order","index__reverse_sort"]
+        index_elements.each_with_index do |name, index|
+          new_a.fields.create(fieldname: name, sorter: index * 10)
+        end
+      end
+    end
+
+    def self.reset_media_block(at)
+      create_fieldgroup(at, "Medien", "last_block", true, true, false, 2, "article_images", 5)
+    end
+
+    def self.reset_meta_block(at)
+      new_a = at.fieldgroups.create(title: "Metadescriptions", position: "last_block", foldable: true, closed: true, expert: false, sorter: 3)
+      metas = ["breadcrumb", "metatag_title_tag", "metatag_meta_description", "metatag_open_graph_title", "metatag_open_graph_description", "robots_no_index"]
+      metas.each_with_index do |name, index|
+        new_a.fields.create(fieldname: name, sorter: index * 10)
+      end
+    end
+
+    def self.reset_widget_block(at)
+      create_fieldgroup(at, "Widgets", "last_block", true, true, false, 4, "widgets", 1)
+    end
+
+    def self.reset_settings_block(at)
+      new_a = at.fieldgroups.create(title: "Einstellungen", position: "last_block", foldable: true, closed: true, expert: false, sorter: 5)
+      setting_elements = ["frontend_tag_list", "url_name", "parent_id", "active_since", "cacheable", "dynamic_redirection",
+                          "external_url_redirect", "redirect_link_title", "redirection_target_in_new_window", "state", "creator"]
+      setting_elements.each_with_index do |name, index|
+        new_a.fields.create(fieldname: name, sorter: index * 10)
+      end
+    end
 
+    def self.create_fieldgroup(at, title, position, foldable, closed, expert, sorter, fieldname, fieldsorter)
+      new_a = at.fieldgroups.create(title: title, position: position, foldable: foldable, closed: closed, expert: expert, sorter: sorter)
+      new_a.fields.create(fieldname: fieldname, sorter: fieldsorter)
+    end
   end
 end

data/app/models/goldencobra/articletype_field.rb

@@ -4,8 +4,9 @@ module Goldencobra
   class ArticletypeField < ActiveRecord::Base
     attr_accessible :articletype_group_id, :class_name, :fieldname, :sorter
 
-    belongs_to :group, :class_name => Goldencobra::ArticletypeGroup, :foreign_key => :articletype_group_id
+    belongs_to :group, class_name: Goldencobra::ArticletypeGroup,
+                      foreign_key: :articletype_group_id
 
-    default_scope order(:sorter)
+    default_scope { order(:sorter) }
   end
 end

data/app/models/goldencobra/articletype_group.rb

@@ -4,10 +4,10 @@ module Goldencobra
   class ArticletypeGroup < ActiveRecord::Base
     attr_accessible :closed, :expert, :foldable, :sorter, :title, :fields_attributes, :position
 
-    belongs_to :articletype, :class_name => Goldencobra::Articletype, :foreign_key => :articletype_id
-    has_many :fields, :class_name => Goldencobra::ArticletypeField, :dependent => :delete_all
-    accepts_nested_attributes_for :fields, :allow_destroy => true
+    belongs_to :articletype, class_name: Goldencobra::Articletype, foreign_key: :articletype_id
+    has_many :fields, class_name: Goldencobra::ArticletypeField, dependent: :delete_all
+    accepts_nested_attributes_for :fields, allow_destroy: true
 
-    default_scope order(:sorter)
+    default_scope { order(:sorter) }
   end
 end

data/app/models/goldencobra/author.rb

@@ -2,13 +2,15 @@
 
 module Goldencobra
 	class Author < ActiveRecord::Base
+    attr_accessible :firstname, :lastname, :email, :googleplus
+
 		has_many  :article_authors
-    has_many  :articles, :through => :article_authors
-    
+    has_many  :articles, through: :article_authors
+
 		web_url :googleplus
 
 		def title
 			[self.try(:firstname), self.try(:lastname)].join(" ")
 		end
 	end
-end
+end

data/app/models/goldencobra/comment.rb

@@ -19,17 +19,17 @@
 
 module Goldencobra
   class Comment < ActiveRecord::Base
-    belongs_to :article, :class_name => Goldencobra::Article, :foreign_key => "article_id"
+    belongs_to :article, class_name: Goldencobra::Article, foreign_key: "article_id"
     belongs_to :commentator, polymorphic: true
-    has_ancestry :orphan_strategy => :rootify
+    has_ancestry orphan_strategy: :rootify
 
     validates_presence_of :article_id, :content, :commentator_id
 
-    scope :approved, where(:approved => true)
-    scope :not_approved, where(:approved => false)
-    scope :active, where(:active => true)
-    scope :reported, where(:reported => true)
-    scope :not_reported_and_active, where(reported: false, active: true)
+    scope :approved, -> { where(approved: true) }
+    scope :not_approved, -> { where(approved: false) }
+    scope :active, -> { where(active: true) }
+    scope :reported, -> { where(reported: true) }
+    scope :not_reported_and_active, -> { where(reported: false, active: true) }
 
     def title
       [self.article.title,self.content[0..20]].join(" - ")

data/app/models/goldencobra/domain.rb

@@ -3,10 +3,10 @@
 module Goldencobra
   class Domain < ActiveRecord::Base
 
-    has_many :permissions, :class_name => Goldencobra::Permission
+    has_many :permissions, class_name: Goldencobra::Permission
 
     validates_presence_of :client
-    validates_format_of :client, :with => /^[\w]+$/
+    validates_format_of :client, with: /\A[\w]+\z/
     validates_presence_of :title
     validates_presence_of :hostname
   	validates_uniqueness_of :hostname
@@ -14,7 +14,7 @@ module Goldencobra
     before_save :mark_as_main
 
     def self.main
-      Goldencobra::Domain.where(:main => true).first
+      Goldencobra::Domain.where(main: true).first
     end
 
     def mark_as_main

data/app/models/goldencobra/import.rb

@@ -23,287 +23,287 @@
 
 module Goldencobra
   class Import < ActiveRecord::Base
-    require 'iconv'
-    require 'csv'
-
-    belongs_to :upload, :class_name => Goldencobra::Upload
-    serialize :assignment
-    serialize :assignment_groups
-    EncodingTypes = ["UTF-8","ISO-8859-1", "ISO-8859-2", "ISO-8859-16", "US-ASCII", "Big5", "UTF-16BE", "IBM437", "Windows-1252"]
-    accepts_nested_attributes_for :upload, :allow_destroy => true, :reject_if => proc { |attributes| attributes['image'].blank? }
-    after_initialize :init_nested_attributes
-    BlockedAttributes = ["id", "created_at", "updated_at", "url_name", "slug", "upload_id", "images", "article_images", "article_widgets", "permissions", "versions"]
-    DataHandling = [["bestehenden Datensatz suchen oder erstellen","update"],["Datensatz immer neu anlegen", "create"]]
-    DataFunctions = ["Default", "Static Value", "DateTime"]
-    def analyze_csv
-      begin
-        result = []
-        data = CSV.read(self.upload.image.path, "r:#{self.encoding_type}", {:col_sep => self.separator})
-        data.first.each_with_index do |a, index|
-          result << [a,index.to_s]
-        end
-      rescue
-        result = []
-      end
-      @analyze_csv ||= result
-    end
-
-    def data_rows
-      begin
-        CSV.read(self.upload.image.path, "r:#{self.encoding_type}", {:col_sep => self.separator})
-      rescue
-        [["Error in reading File: Please check encoding type"]]
-      end
-    end
-
-    def get_model_attributes
-      @get_model_attributes ||= eval("#{self.target_model}.new.attributes").delete_if{|a| BlockedAttributes.include?(a) }.keys
-    end
-
-    def get_association_names(current_target_model=nil)
-      if current_target_model.present?
-        current_target_model.reflect_on_all_associations.collect { |r| r.name }.delete_if{|a| Goldencobra::Import::BlockedAttributes.include?(a.to_s) }
-      else
-        self.target_model.constantize.reflect_on_all_associations.collect { |r| r.name }.delete_if{|a| Goldencobra::Import::BlockedAttributes.include?(a.to_s) }
-      end
-    end
-
-    def method_missing(meth, *args, &block)
-      if meth.to_s.include?("assignment_") && self.assignment.present?
-        self.assignment[meth.to_s.split("_")[1]]
-      end
-    end
-
-    def status
-      @status ||="ready to import"
-    end
-
-
-    def run!
-      self.result = []
-      count = 0
-      all_data_attribute_assignments = remove_empty_assignments
-      master_data_attribute_assignments = all_data_attribute_assignments[self.target_model]
-      import_data_attribute_assignments = all_data_attribute_assignments["Goldencobra::ImportMetadata"]
-      #all_data_attribute_assignments.delete("Goldencobra::ImportMetadata")
-
-      data = CSV.read(self.upload.image.path, "r:#{self.encoding_type}", {:col_sep => self.separator})
-      data.each do |row|
-        if count == 0
-          count = 1
-          next
-        end
-        master_object = nil
-        current_object = nil
-        #Neues Object anlegen oder bestehendes suchen und aktualisieren
-        master_object = create_or_update_target_model(self.target_model,self.target_model,master_data_attribute_assignments, row )
-
-        #Wenn es aus irgend einem Grund kein Master Object gibt
-        raise "No Master Object found" if master_object.blank?
-
-        #Gehe alle Zugewiesenen Attribute durch und erzeuge die Datensätze
-        all_data_attribute_assignments.each do |key_string,sub_assignments|
-          raise "all_data_attribute_assignments is blank!" if all_data_attribute_assignments.blank?
-          key = key_string.split("_")[0]
-          key_relation_name = key_string.split("_")[1]
-          #Metadaten werden zu jedem Datensatz separat erfasst
-          next if key == "Goldencobra::ImportMetadata"
-          if key == self.target_model
-            current_object = master_object
-          else
-            unless key_relation_name.present?
-              key_relation_name = get_associations_for_current_object(current_object)[key]
-              key_relation_name = key_relation_name.first if key_relation_name.class == Array
-            end
-            current_object = create_or_update_target_model(key,key,sub_assignments, row )
-            add_current_submodel_to_model(master_object, current_object, key_relation_name )
-          end
-
-          #Wenn es aus irgend einem Grund kein Current object gibt
-          raise "current_object is blank: #{key}, #{sub_assignments}, #{row}" if current_object.blank?
-
-          #die Werte für das Object werden gesetzt
-          sub_assignments.each do |attribute_name,value|
-            #Wenn das Aktuell zu speichernde Attribute kein attribute sondern eine Assoziazion zu einem anderen Model ist...
-            sub_assoziations = get_associations_for_current_object(current_object)
-            if sub_assoziations.map{|a| a[0]}.include?(attribute_name)
-              self.assignment["#{current_object.class.to_s}"][attribute_name].each do |sub_attribute_name, sub_value|
-                if current_object.send(sub_attribute_name).class == Array
-                  #Bei einer has_many beziehung
-                  cass_related_sub_model = eval("current_object.#{sub_attribute_name}.new")
-                else
-                  #bei einer belongs_to Beziehung
-                  cass_related_sub_model = current_object.send("build_#{sub_attribute_name}")
-                end
-
-                sub_sub_assignments = self.assignment["#{current_object.class.to_s}"][attribute_name][sub_attribute_name]
-                #Neues Unter Object anlegen oder bestehendes suchen und aktualisieren
-                current_sub_object = create_or_update_target_model("#{current_object.class.to_s}_#{cass_related_sub_model.class.to_s}_#{sub_attribute_name}",attribute_name,sub_sub_assignments, row )
-                puts current_sub_object.inspect
-                #Das aktuelle unterobjeect wird dem Elternelement hinzugefügt
-                # wenn es eine has_many beziehung ist:
-
-                puts sub_sub_assignments.inspect
-                sub_sub_assignments.each do |sub_ass_item|
-                  if assignment_exists?(value)
-                    sub_data_to_save = parse_data_with_method(value['csv'],value['data_function'],value['option'], current_sub_object.class.to_s, row)
-                    current_sub_object.send("#{sub_ass_item}=", sub_data_to_save) if sub_data_to_save.blank?
-                    puts current_sub_object.inspect
-                  end
-                end
-                if current_sub_object.save
-                  add_current_submodel_to_model(current_object, current_sub_object, sub_attribute_name )
-                end
-              end
-            else
-              if assignment_exists?(value)
-                data_to_save = parse_data_with_method(value['csv'],value['data_function'],value['option'], current_object.class.to_s, row)
-              end
-              #Wenn das Aktuell zu speichernde Attribute wirklich ein Attribute ist, kann es gespeichert werden
-              current_object.send("#{attribute_name}=", data_to_save) if data_to_save.present?
-            end
-          end
-          #Das Object wird gespeichert
-          if current_object.save
-            #Create ImportMetadata
-            import_metadata = Goldencobra::ImportMetadata.new
-            import_data_attribute_assignments.each do |attribute_name,value|
-              data_to_save = parse_data_with_method(value['csv'],value['data_function'],value['option'], "Goldencobra::ImportMetadata", row)
-              next if data_to_save.blank?
-              import_metadata.send("#{attribute_name}=", data_to_save)
-            end
-            import_metadata.importmetatagable = current_object
-            import_metadata.save
-          else
-            #self.result << "#{count} - SubObject: #{current_object.errors.messages}"
-          end
-        end
-        #Das Elternelement wird gespeichert
-        unless master_object.save
-          raise "master_object could not be saved! #{master_object.errors.inspect}"
-          self.result << "#{count} - #{master_object.errors.messages}"
-        end
-        count += 1
-      end
-      self.save
-    end
-
-
-    def init_nested_attributes
-      self.upload ||= build_upload
-      self.assignment ||= {}
-    end
-
-    def find_or_create_by_attributes(attribute_assignments, row, model_name)
-      find_condition = []
-      attribute_assignments.each do |attribute_name,value|
-        if assignment_exists?(value)
-          data_to_search = parse_data_with_method(value['csv'],value['data_function'],value['option'], model_name, row)
-          if data_to_search.blank?
-            find_condition << "#{attribute_name} = '#{data_to_search}'"
-          end
-        end
-      end
-      find_master = model_name.constantize.where(find_condition.join(' AND '))
-
-      if find_master.count == 0
-        return model_name.constantize.new
-      elsif find_master.count == 1
-        return find_master.first
-      else
-        self.result << "Dieses Object exisitiert schon mehrfach, keine eindeutige Zuweisung möglich: Erstes Objekt wird verwendet (#{row})"
-        return find_master.first
-      end
-    end
-
-    #SELECT COUNT(*) FROM `providers` WHERE (title = 'Sportgemeinschaft Siemens Berlin e. V.' AND category_id = '3' AND metatag_external_id = '1804' AND metatag_created_at = '06.01.2010')
-
-    def parse_data_with_method(data,data_function,data_option, model_name="", row)
-      if data.present?
-        row_data = row[data.to_i]
-        conv = Iconv.new("UTF-8", self.encoding_type)
-        output = conv.iconv(row_data)
-      else
-        output = nil
-      end
-      if data_function == "Default"
-        return output
-      elsif data_function == "Static Value"
-        return data_option
-      elsif data_function == "DateTime"
-        if output.present? && data_option.present?
-          return DateTime.strptime(output,data_option).strftime("%Y-%m-%d %H:%M")
-        else
-          return output
-        end
-      elsif model_name.present?
-        if data_function.present? && model_name.constantize.respond_to?(data_function.parameterize.underscore)
-          return model_name.constantize.send(data_function.parameterize.underscore, row_data, data_option )
-        else
-          return ""
-        end
-      else
-        return ""
-      end
-    end
-
-    def remove_empty_assignments
-      self.assignment.each do |key, values|
-        self.assignment[key].delete_if{|k,v| v['data_function'] == "Default" && v['csv'].blank?} if self.assignment[key].present? && self.assignment[key].class == Array
-        if self.assignment[key].blank?
-          self.assignment.delete(key)
-        end
-      end
-      self.assignment
-    end
-
-
-    def create_or_update_target_model(assignment_groups_definition,target_model,master_data_attribute_assignments, data_row )
-      if self.assignment_groups.present?
-        if self.assignment_groups[assignment_groups_definition] == "create"
-          return target_model.constantize.new
-        else
-          return find_or_create_by_attributes(master_data_attribute_assignments, data_row, target_model)
-        end
-      else
-        raise "self.assignment_groups is blank! #{}"
-      end
-    end
-
-    def add_current_submodel_to_model(current_object, current_sub_object, sub_attribute_name )
-      if sub_attribute_name.present? && current_object.present? && current_sub_object.present?
-        begin
-          if current_object.send(sub_attribute_name).class == Array
-            current_object.send(sub_attribute_name) << current_sub_object
-          else
-            eval("current_object.#{sub_attribute_name} = current_sub_object")
-          end
-        rescue  => e
-          logger.warn("***"*20)
-          logger.warn("Current Submodel cannot be added to model: #{sub_attribute_name} #{e}")
-        end
-      end
-    end
-
-
-    def get_associations_for_current_object(current_object)
-      h = {}
-      ass = current_object.class.reflect_on_all_associations.collect { |r| [r.name, r.macro] }
-      ass.each do |a|
-        #if a[1].to_s == "has_many"
-          a_class_name = current_object.reflections[a[0].to_sym].class_name
-          h[a_class_name] ||= []
-          h[a_class_name] << a[0]
-        # elsif current_object.respond_to?("build_#{a[0]}")
-        #   h[current_object.send("build_#{a[0]}").class.to_s] ||= []
-        #   h[current_object.send("build_#{a[0]}").class.to_s] << a[0]
-        # end
-      end
-      return h
-    end
-
-    def assignment_exists?(value)
-      value.present? && ((value['data_function'].present? && value['data_function'] != 'Default') || value['csv'].present?)
-    end
+  #   require 'iconv'
+  #   require 'csv'
+
+  #   belongs_to :upload, class_name: Goldencobra::Upload
+  #   serialize :assignment
+  #   serialize :assignment_groups
+  #   EncodingTypes = ["UTF-8","ISO-8859-1", "ISO-8859-2", "ISO-8859-16", "US-ASCII", "Big5", "UTF-16BE", "IBM437", "Windows-1252"]
+  #   accepts_nested_attributes_for :upload, allow_destroy: true, reject_if: proc { |attributes| attributes['image'].blank? }
+  #   after_initialize :init_nested_attributes
+  #   BlockedAttributes = ["id", "created_at", "updated_at", "url_name", "slug", "upload_id", "images", "article_images", "article_widgets", "permissions", "versions"]
+  #   DataHandling = [["bestehenden Datensatz suchen oder erstellen","update"],["Datensatz immer neu anlegen", "create"]]
+  #   DataFunctions = ["Default", "Static Value", "DateTime"]
+  #   def analyze_csv
+  #     begin
+  #       result = []
+  #       data = CSV.read(self.upload.image.path, "r:#{self.encoding_type}", {col_sep: self.separator})
+  #       data.first.each_with_index do |a, index|
+  #         result << [a,index.to_s]
+  #       end
+  #     rescue
+  #       result = []
+  #     end
+  #     @analyze_csv ||= result
+  #   end
+
+  #   def data_rows
+  #     begin
+  #       CSV.read(self.upload.image.path, "r:#{self.encoding_type}", {col_sep: self.separator})
+  #     rescue
+  #       [["Error in reading File: Please check encoding type"]]
+  #     end
+  #   end
+
+  #   def get_model_attributes
+  #     @get_model_attributes ||= eval("#{self.target_model}.new.attributes").delete_if{|a| BlockedAttributes.include?(a) }.keys
+  #   end
+
+  #   def get_association_names(current_target_model=nil)
+  #     if current_target_model.present?
+  #       current_target_model.reflect_on_all_associations.collect { |r| r.name }.delete_if{|a| Goldencobra::Import::BlockedAttributes.include?(a.to_s) }
+  #     else
+  #       self.target_model.constantize.reflect_on_all_associations.collect { |r| r.name }.delete_if{|a| Goldencobra::Import::BlockedAttributes.include?(a.to_s) }
+  #     end
+  #   end
+
+  #   def method_missing(meth, *args, &block)
+  #     if meth.to_s.include?("assignment_") && self.assignment.present?
+  #       self.assignment[meth.to_s.split("_")[1]]
+  #     end
+  #   end
+
+  #   def status
+  #     @status ||="ready to import"
+  #   end
+
+
+  #   def run!
+  #     self.result = []
+  #     count = 0
+  #     all_data_attribute_assignments = remove_empty_assignments
+  #     master_data_attribute_assignments = all_data_attribute_assignments[self.target_model]
+  #     import_data_attribute_assignments = all_data_attribute_assignments["Goldencobra::ImportMetadata"]
+  #     #all_data_attribute_assignments.delete("Goldencobra::ImportMetadata")
+
+  #     data = CSV.read(self.upload.image.path, "r:#{self.encoding_type}", {col_sep: self.separator})
+  #     data.each do |row|
+  #       if count == 0
+  #         count = 1
+  #         next
+  #       end
+  #       master_object = nil
+  #       current_object = nil
+  #       #Neues Object anlegen oder bestehendes suchen und aktualisieren
+  #       master_object = create_or_update_target_model(self.target_model,self.target_model,master_data_attribute_assignments, row )
+
+  #       #Wenn es aus irgend einem Grund kein Master Object gibt
+  #       raise "No Master Object found" if master_object.blank?
+
+  #       #Gehe alle Zugewiesenen Attribute durch und erzeuge die Datensätze
+  #       all_data_attribute_assignments.each do |key_string,sub_assignments|
+  #         raise "all_data_attribute_assignments is blank!" if all_data_attribute_assignments.blank?
+  #         key = key_string.split("_")[0]
+  #         key_relation_name = key_string.split("_")[1]
+  #         #Metadaten werden zu jedem Datensatz separat erfasst
+  #         next if key == "Goldencobra::ImportMetadata"
+  #         if key == self.target_model
+  #           current_object = master_object
+  #         else
+  #           unless key_relation_name.present?
+  #             key_relation_name = get_associations_for_current_object(current_object)[key]
+  #             key_relation_name = key_relation_name.first if key_relation_name.class == Array
+  #           end
+  #           current_object = create_or_update_target_model(key,key,sub_assignments, row )
+  #           add_current_submodel_to_model(master_object, current_object, key_relation_name )
+  #         end
+
+  #         #Wenn es aus irgend einem Grund kein Current object gibt
+  #         raise "current_object is blank: #{key}, #{sub_assignments}, #{row}" if current_object.blank?
+
+  #         #die Werte für das Object werden gesetzt
+  #         sub_assignments.each do |attribute_name,value|
+  #           #Wenn das Aktuell zu speichernde Attribute kein attribute sondern eine Assoziazion zu einem anderen Model ist...
+  #           sub_assoziations = get_associations_for_current_object(current_object)
+  #           if sub_assoziations.map{|a| a[0]}.include?(attribute_name)
+  #             self.assignment["#{current_object.class.to_s}"][attribute_name].each do |sub_attribute_name, sub_value|
+  #               if current_object.send(sub_attribute_name).class == Array
+  #                 #Bei einer has_many beziehung
+  #                 cass_related_sub_model = eval("current_object.#{sub_attribute_name}.new")
+  #               else
+  #                 #bei einer belongs_to Beziehung
+  #                 cass_related_sub_model = current_object.send("build_#{sub_attribute_name}")
+  #               end
+
+  #               sub_sub_assignments = self.assignment["#{current_object.class.to_s}"][attribute_name][sub_attribute_name]
+  #               #Neues Unter Object anlegen oder bestehendes suchen und aktualisieren
+  #               current_sub_object = create_or_update_target_model("#{current_object.class.to_s}_#{cass_related_sub_model.class.to_s}_#{sub_attribute_name}",attribute_name,sub_sub_assignments, row )
+  #               puts current_sub_object.inspect
+  #               #Das aktuelle unterobjeect wird dem Elternelement hinzugefügt
+  #               # wenn es eine has_many beziehung ist:
+
+  #               puts sub_sub_assignments.inspect
+  #               sub_sub_assignments.each do |sub_ass_item|
+  #                 if assignment_exists?(value)
+  #                   sub_data_to_save = parse_data_with_method(value['csv'],value['data_function'],value['option'], current_sub_object.class.to_s, row)
+  #                   current_sub_object.send("#{sub_ass_item}=", sub_data_to_save) if sub_data_to_save.blank?
+  #                   puts current_sub_object.inspect
+  #                 end
+  #               end
+  #               if current_sub_object.save
+  #                 add_current_submodel_to_model(current_object, current_sub_object, sub_attribute_name )
+  #               end
+  #             end
+  #           else
+  #             if assignment_exists?(value)
+  #               data_to_save = parse_data_with_method(value['csv'],value['data_function'],value['option'], current_object.class.to_s, row)
+  #             end
+  #             #Wenn das Aktuell zu speichernde Attribute wirklich ein Attribute ist, kann es gespeichert werden
+  #             current_object.send("#{attribute_name}=", data_to_save) if data_to_save.present?
+  #           end
+  #         end
+  #         #Das Object wird gespeichert
+  #         if current_object.save
+  #           #Create ImportMetadata
+  #           import_metadata = Goldencobra::ImportMetadata.new
+  #           import_data_attribute_assignments.each do |attribute_name,value|
+  #             data_to_save = parse_data_with_method(value['csv'],value['data_function'],value['option'], "Goldencobra::ImportMetadata", row)
+  #             next if data_to_save.blank?
+  #             import_metadata.send("#{attribute_name}=", data_to_save)
+  #           end
+  #           import_metadata.importmetatagable = current_object
+  #           import_metadata.save
+  #         else
+  #           #self.result << "#{count} - SubObject: #{current_object.errors.messages}"
+  #         end
+  #       end
+  #       #Das Elternelement wird gespeichert
+  #       unless master_object.save
+  #         raise "master_object could not be saved! #{master_object.errors.inspect}"
+  #         self.result << "#{count} - #{master_object.errors.messages}"
+  #       end
+  #       count += 1
+  #     end
+  #     self.save
+  #   end
+
+
+  #   def init_nested_attributes
+  #     self.upload ||= build_upload
+  #     self.assignment ||= {}
+  #   end
+
+  #   def find_or_create_by_attributes(attribute_assignments, row, model_name)
+  #     find_condition = []
+  #     attribute_assignments.each do |attribute_name,value|
+  #       if assignment_exists?(value)
+  #         data_to_search = parse_data_with_method(value['csv'],value['data_function'],value['option'], model_name, row)
+  #         if data_to_search.blank?
+  #           find_condition << "#{attribute_name} = '#{data_to_search}'"
+  #         end
+  #       end
+  #     end
+  #     find_master = model_name.constantize.where(find_condition.join(' AND '))
+
+  #     if find_master.count == 0
+  #       return model_name.constantize.new
+  #     elsif find_master.count == 1
+  #       return find_master.first
+  #     else
+  #       self.result << "Dieses Object exisitiert schon mehrfach, keine eindeutige Zuweisung möglich: Erstes Objekt wird verwendet (#{row})"
+  #       return find_master.first
+  #     end
+  #   end
+
+  #   #SELECT COUNT(*) FROM `providers` WHERE (title = 'Sportgemeinschaft Siemens Berlin e. V.' AND category_id = '3' AND metatag_external_id = '1804' AND metatag_created_at = '06.01.2010')
+
+  #   def parse_data_with_method(data,data_function,data_option, model_name="", row)
+  #     if data.present?
+  #       row_data = row[data.to_i]
+  #       conv = Iconv.new("UTF-8", self.encoding_type)
+  #       output = conv.iconv(row_data)
+  #     else
+  #       output = nil
+  #     end
+  #     if data_function == "Default"
+  #       return output
+  #     elsif data_function == "Static Value"
+  #       return data_option
+  #     elsif data_function == "DateTime"
+  #       if output.present? && data_option.present?
+  #         return DateTime.strptime(output,data_option).strftime("%Y-%m-%d %H:%M")
+  #       else
+  #         return output
+  #       end
+  #     elsif model_name.present?
+  #       if data_function.present? && model_name.constantize.respond_to?(data_function.parameterize.underscore)
+  #         return model_name.constantize.send(data_function.parameterize.underscore, row_data, data_option )
+  #       else
+  #         return ""
+  #       end
+  #     else
+  #       return ""
+  #     end
+  #   end
+
+  #   def remove_empty_assignments
+  #     self.assignment.each do |key, values|
+  #       self.assignment[key].delete_if{|k,v| v['data_function'] == "Default" && v['csv'].blank?} if self.assignment[key].present? && self.assignment[key].class == Array
+  #       if self.assignment[key].blank?
+  #         self.assignment.delete(key)
+  #       end
+  #     end
+  #     self.assignment
+  #   end
+
+
+  #   def create_or_update_target_model(assignment_groups_definition,target_model,master_data_attribute_assignments, data_row )
+  #     if self.assignment_groups.present?
+  #       if self.assignment_groups[assignment_groups_definition] == "create"
+  #         return target_model.constantize.new
+  #       else
+  #         return find_or_create_by_attributes(master_data_attribute_assignments, data_row, target_model)
+  #       end
+  #     else
+  #       raise "self.assignment_groups is blank! #{}"
+  #     end
+  #   end
+
+  #   def add_current_submodel_to_model(current_object, current_sub_object, sub_attribute_name )
+  #     if sub_attribute_name.present? && current_object.present? && current_sub_object.present?
+  #       begin
+  #         if current_object.send(sub_attribute_name).class == Array
+  #           current_object.send(sub_attribute_name) << current_sub_object
+  #         else
+  #           eval("current_object.#{sub_attribute_name} = current_sub_object")
+  #         end
+  #       rescue  => e
+  #         logger.warn("***"*20)
+  #         logger.warn("Current Submodel cannot be added to model: #{sub_attribute_name} #{e}")
+  #       end
+  #     end
+  #   end
+
+
+  #   def get_associations_for_current_object(current_object)
+  #     h = {}
+  #     ass = current_object.class.reflect_on_all_associations.collect { |r| [r.name, r.macro] }
+  #     ass.each do |a|
+  #       #if a[1].to_s == "has_many"
+  #         a_class_name = current_object.reflections[a[0].to_sym].class_name
+  #         h[a_class_name] ||= []
+  #         h[a_class_name] << a[0]
+  #       # elsif current_object.respond_to?("build_#{a[0]}")
+  #       #   h[current_object.send("build_#{a[0]}").class.to_s] ||= []
+  #       #   h[current_object.send("build_#{a[0]}").class.to_s] << a[0]
+  #       # end
+  #     end
+  #     return h
+  #   end
+
+  #   def assignment_exists?(value)
+  #     value.present? && ((value['data_function'].present? && value['data_function'] != 'Default') || value['csv'].present?)
+  #   end
   end
 end