infopark_fiona_connector 6.8.0.beta.200.891.647580e

data/lib/rails_connector/default_search_request.rb

@@ -0,0 +1,6 @@
+module RailsConnector
+  # This class provides a default implementation for accessing the search server.
+  # It is used by DefaultSearchController.
+  class DefaultSearchRequest < VeritySearchRequest
+  end
+end

data/lib/rails_connector/errors.rb

@@ -0,0 +1,8 @@
+require "active_record/errors"
+
+module RailsConnector
+
+ResourceNotFound = ActiveRecord::RecordNotFound
+
+end # module RailsConnector
+

data/lib/rails_connector/link.rb

@@ -0,0 +1,135 @@
+module RailsConnector
+  # This class provides an interfaces for handling CMS Links.
+  # To format a link for rendering in an html page, use the +cms_path+ or +cms_url+ methods.
+  class Link
+
+    extend ActiveModel::Naming
+
+    def initialize(link_data, destination_object = nil) #:nodoc:
+      @link_data = link_data.symbolize_keys
+      @destination_object = destination_object
+    end
+
+    # The link's external url. Only available for external links.
+    # Warning: Do not output the url directly unless you know what you are doing.
+    # Normally you want to use the +cms_path+ or +cms_url+ methods to format a link.
+    def url
+      @link_data[:url]
+    end
+
+    # The link's title.
+    def title
+      @link_data[:title]
+    end
+
+    # Returns the link's query string as in "index.html?query_string".
+    # See RFC3986 for details (http://www.ietf.org/rfc/rfc3986.txt).
+    def query
+      @link_data[:search]
+    end
+
+    # Deprecated: use Link#query instead.
+    # Returns the link's query string as in "index.html?query_string".
+    # See RFC3986 for details (http://www.ietf.org/rfc/rfc3986.txt).
+    def search
+      query
+    end
+
+    # Returns the link's anchor as in "index.html#anchor".
+    # See RFC3986 for details (http://www.ietf.org/rfc/rfc3986.txt).
+    def fragment
+      @link_data[:fragment]
+    end
+
+    # Returns the browser window or browser frame to be used as a target for this link.
+    # Example: Links that should be opened in a new window will return "_blank" as their target.
+    def target
+      @link_data[:target]
+    end
+
+    def id #:nodoc:
+      @link_data[:link_id]
+    end
+
+    def tag_name # :nodoc:
+      @link_data[:tag_name]
+    end
+
+    def markdown_type # :nodoc:
+      @link_data[:markdown_type]
+    end
+
+    def markdown? # :nodoc:
+      'markdown' == @link_data[:source_format]
+    end
+
+    # Returns the file extension (e.g. zip, pdf) of this link's (internal or external) target.
+    # Returns an empty string if the file extension is can not be determined.
+    def file_extension
+      if internal?
+        destination_object ? destination_object.file_extension : ""
+      else
+        path = URI.parse(url).path rescue nil
+        path.blank? ? "" : File.extname(path)[1..-1] || ""
+      end
+    end
+
+    # Returns the id of the Links' destination_object.
+    def destination_object_id
+      destination
+    end
+
+    # Returns the title of this Link if it is set.
+    # Otherwise it returns the display_title of the destination object for internal Links
+    # or the URL for external Links.
+    def display_title
+      dt = title
+      dt = destination_object.display_title if dt.blank? && !external?
+      dt = url if dt.blank?
+      dt
+    end
+
+    # Returns true this Link links to a CMS Object.
+    def internal?
+      url.nil?
+    end
+
+    # Returns true if this Link links to an external URL.
+    def external?
+      !internal?
+    end
+
+    # An internal Link is active if it's destination object is active.
+    # An external Link is always active.
+    def active?
+      external? || (destination_object && destination_object.active?)
+    end
+
+    def external_prefix? #:nodoc:
+      url =~ /\s?external:/
+    end
+
+    def resolved? #:nodoc:
+      external? || resolved_internal?
+    end
+
+    # Returns the destination object (+Obj+) of this Link.
+    def destination_object
+      @destination_object ||= Obj.find(destination) if resolved_internal?
+    end
+
+    def to_liquid # :nodoc:
+      LiquidSupport::LinkDrop.new(self)
+    end
+
+    private
+
+    def resolved_internal?
+      internal? && !destination.nil?
+    end
+
+    def destination
+      @link_data[:destination]
+    end
+  end
+end

data/lib/rails_connector/lucene_search_request.rb

@@ -0,0 +1,107 @@
+#:enddoc:
+require 'rsolr'
+
+module RailsConnector
+
+  # This class provides a basic implementation for accessing a Solr search server.
+  # It can be activated by making it the superclass of SearchRequest
+  # (instead of DefaultSearchRequest).
+  # It should be customized by subclassing.
+  class LuceneSearchRequest
+    attr_reader :query_string
+
+    # Sanitizes the given +query_string+ and takes +options+ for accessing Solr.
+    #
+    # +options+ is a hash and may include:
+    #
+    # <tt>:limit</tt>:: The maximum number of hits
+    # <tt>:offset</tt>:: The search offset
+    # <tt>:solr_url</tt>:: A non-default Solr server URL
+    # <tt>:filter_query</tt>:: See #filter_query_conditions
+    # <tt>:solr_parameters</tt>:: A hash of additional query parameters (e. g. +timeAllowed+, +sort+)
+    # <tt>:lazy_load</tt>:: when set to false (the default), the hits will load their associated Objs immediatley. Otherwise they will be loaded lazyly (when accessed through Hit#obj). Note that loading lazyly may expose hits that do not have an Obj, i.e. they return nil when Hit#obj is invoked. When loading immediately, those hits are filtered.
+    def initialize(query_string, options = nil)
+      @query_string = self.class.sanitize(query_string)
+      @options = Configuration.search_options.merge(options || {})
+    end
+
+    # Accesses Solr and fetches search hits.
+    #
+    # Uses the #filter_query and +options+ given in #new.
+    def fetch_hits
+      solr = RSolr.connect(:url => @options[:solr_url])
+      solr_result = solr.get("select", :params => solr_query_parameters)
+      solr_response = solr_result['response']
+      build_search_result(solr_response['numFound'], solr_response['docs'], solr_response['maxScore'])
+    end
+
+    # Removes unwanted characters from +text+.
+    def self.sanitize(text) #:nodoc:
+      text.gsub(/[^\w\*]/, ' ').gsub(/\s+/, ' ').strip
+    end
+
+    def solr_query_for_query_string
+      @query_string.downcase.split(/\s+/).map do |word|
+        word unless %w(and or not).include?(word)
+      end.compact.join(" AND ")
+    end
+
+    # Combines filter query conditions (see #filter_query_conditions).
+    #
+    # A filter query is used to reduce the number of documents before executing the actual query.
+    # By default, all filter query conditions must be met, each is passed on as a separate filter query.
+    def filter_query
+      filter_query_conditions.values.compact
+    end
+
+    # A hash of conditions, combined to a filter query by #filter_query.
+    # Note that all values of the hash must be valid Solr syntax.
+    # The keys have no meaning and exist only so single conditions can be replaced
+    # in a subclass:
+    #
+    #   class SearchRequest < LuceneSearchRequest
+    #     def filter_query_conditions
+    #       super.merge(:subset => 'path:/de/*')
+    #     end
+    #   end
+    def filter_query_conditions
+      conditions = {}
+      conditions[:object_type] = 'NOT object_type:image'
+      conditions[:suppress_export] = 'NOT suppress_export:1'
+      now = Time.now
+      conditions[:valid_from] = "NOT valid_from:[#{now.succ.to_iso} TO *]"
+      conditions[:valid_until] = "NOT valid_until:[* TO #{now.to_iso}]"
+      conditions.merge(@options[:filter_query] || {})
+    end
+
+    private
+
+    def solr_query_parameters
+      {
+        :q => solr_query_for_query_string,
+        :fq => filter_query,
+        :fl => 'id,score',
+        :start => @options[:offset],
+        :rows => @options[:limit]
+      }.merge(@options[:solr_parameters] || {})
+    end
+
+    def build_search_result(total_hits, docs, max_score)
+      result = SES::SearchResult.new(total_hits)
+      docs.each do |doc|
+        begin
+          id = doc['id']
+          score = doc['score'] / max_score
+          hit = SES::Hit.new(id, score, doc)
+          if @options[:lazy_load].blank? && hit.obj.blank?
+            Rails.logger.warn("OBJ with ID ##{doc['id']} not found: This search result will not be shown")
+          else
+            result << hit
+          end
+        end
+      end
+      result
+    end
+  end
+
+end

data/lib/rails_connector/named_link.rb

@@ -0,0 +1,76 @@
+module RailsConnector
+
+  # This class provides methods used to retrieve objects from CMS based an entry
+  # in CMS of the obj_class <tt>NamedLink</tt>.
+
+  class NamedLink < Obj
+
+    class NotFound < StandardError
+    end
+
+    @@named_links_cache = nil
+    @@updated_at = nil
+    @@cache_expiry_time = nil
+
+    # Generates a cache of named links based on the CMS objects related link list.
+    # Raises exceptions if zero or more than one objects have this obj_class
+    def self.generate_named_links_cache
+      return if @@named_links_cache
+
+      found_objects = self.all
+      Rails.logger.warn "Couldn't find NamedLink CMS Object!" if found_objects.empty?
+      Rails.logger.warn "More than one NamedLink CMS Object found!" if found_objects.size > 1
+
+      @@named_links_cache = found_objects.
+        sort_by(&:valid_from).
+        reverse.
+        map(&:related_links).
+        flatten(1).
+        each_with_object({}) do |link_obj, temp|
+          temp[link_obj.title] = link_obj.destination_object
+        end
+
+      @@updated_at = Time.now
+      return nil
+    end
+
+    # Sets the time in minutes after which the cache will be expired.
+    # The default expiry time is set to 1 minute
+    def self.cache_expiry_time=(value)
+      @@cache_expiry_time = value
+    end
+
+    def self.cache_expiry_time #:nodoc:
+      @@cache_expiry_time || 1
+    end
+
+    def self.cache_expired? #:nodoc:
+      @@updated_at.nil? || @@updated_at <= cache_expiry_time.minute.ago
+    end
+
+    # Returns the CMS object mapped to the given title or nil.
+    # The title can be a string of symbol.
+    # If :cache => false is provided, the object will not be fetched from the cache.
+    def self.get_object(title, options = {})
+      object = named_links[title.to_s]
+      raise NotFound, "The NamedLink '#{title.to_s}' does not exist" if object.nil?
+      options[:cache] == false ? object.reload : object
+    end
+
+    def self.reset_cache #:nodoc:
+      @@named_links_cache = nil
+    end
+
+    def self.named_links #:nodoc:
+      reset_cache if cache_expired?
+      generate_named_links_cache unless named_links_cache
+      named_links_cache
+    end
+
+    def self.named_links_cache #:nodoc:
+      @@named_links_cache
+    end
+
+  end
+
+end

data/lib/rails_connector/news.rb

@@ -0,0 +1,16 @@
+module RailsConnector
+
+  # The CMS news object
+  #
+  # This class models the join table between channels and objects.
+  # Instances of this class also hold information about validity range.
+
+  class News < CmsBaseModel
+
+    self.primary_key = "news_id"
+
+    belongs_to :object, :class_name => 'Obj', :foreign_key => 'object_id'
+
+  end
+
+end

data/lib/rails_connector/obj.rb

@@ -0,0 +1,517 @@
+require "json"
+
+module RailsConnector
+
+  # The CMS file class
+  #
+  # [children] an Array of objects, Obj, of which this one is the parent
+  # [parent] the Obj of which this one is a child - nil for the root object
+  # [sort_value] the sort value of this object with respect to its siblings, calculated using the sort criteria of the parent
+  class Obj < CmsBaseModel
+    include AttrValueProvider
+    include DateAttribute
+    include SEO
+
+    self.store_full_sti_class = false
+
+    def self.configure_for_content(which) # :nodoc:
+      case which
+      when :released then configure_column_information("objs", true)
+      when :edited
+        configure_column_information("preview_objs", false)
+        has_many(:permissions, :class_name => "::RailsConnector::Permission", :foreign_key => "object_id")
+      else
+        raise "configure_for_content called with unknown parameter #{which}"
+      end
+    end
+
+    def self.configure_column_information(table_name_postfix, use_cached_permissions)
+      reset_column_information
+
+      self.table_name = "#{table_name_prefix}#{table_name_postfix}"
+      self.primary_key = "obj_id"
+      self.inheritance_column = "obj_class"
+
+      @@use_cached_permissions = use_cached_permissions
+    end
+
+    # use released contents as a default
+    configure_for_content(:released)
+
+    # Patch to avoid a type_condition being added by ActiveRecord::Base.add_conditions! for Obj.find(params):
+    def self.descends_from_active_record? # :nodoc:
+      superclass == CmsBaseModel
+    end
+
+    # A CMS administrator can specify the <tt>obj_class</tt> for a given CMS object.
+    # In Rails, this could be either:
+    #
+    # * A valid and existing model name
+    # * A valid and non-existing model name
+    # * An invalid model name
+    #
+    # Rails' STI mechanism only considers the first case.
+    # In any other case, RailsConnector::Obj is used, except when explicitely asked
+    # for a model in the RailsConnector namespace (RailsConnector::Permission etc.)
+
+    def self.compute_type(type_name) # :nodoc:
+      try_type { type_name.constantize } ||
+      self
+    end
+
+    def permissions
+      @@use_cached_permissions ? attr_dict.permissions : super
+    end
+
+    def permitted_for_user?(user)
+      if permitted_groups.blank?
+        true
+      else
+        if user
+          (permitted_groups & user.live_server_groups).any?
+        else
+          false
+        end
+      end
+    end
+
+    # Returns the root Obj. Its id is 2001 and cannot be changed.
+    def self.root
+      Obj.find(2001)
+    end
+
+    # Returns the homepage object. This can be overwritten in your application's +ObjExtensions+.
+    # Use <tt>Obj#homepage?</tt> to check if an object is the homepage.
+    def self.homepage
+      root
+    end
+
+    # for testing purposes only
+    def self.reset_homepage #:nodoc:
+      @@homepage_id = nil
+    end
+
+     # returns the obj's permalink.
+     def permalink
+       self[:permalink]
+     end
+
+    # This method determines the controller that should be invoked when the Obj is requested.
+    # By default a controller matching the Obj's obj_class will be used.
+    # If the controller does not exist, the CmsController will be used as a fallback.
+    # Overwrite this method to force a different controller to be used.
+    def controller_name
+      obj_class
+    end
+
+    # This method determines the action that should be invoked when the Obj is requested.
+    # The default action is 'index'.
+    # Overwrite this method to force a different action to be used.
+    def controller_action_name
+      "index"
+    end
+
+    @@homepage_id = nil
+    # Returns true if the current object has the same id as the homepage object. Always use this method instead of
+    # manually comparing an object to <tt>Obj.homepage</tt>, as Obj#homepage? caches the object id
+    # and thus requires no extra database access.
+    def homepage?
+      self.id == (@@homepage_id ||= self.class.homepage.id)
+    end
+
+    # Returns the title of the content or the name.
+    def display_title
+      self.title || name
+    end
+
+    OBJECT_TYPES = {
+      '2' => :document,
+      '5' => :publication,
+      'B' => :image,
+      'C' => :generic
+    }.freeze unless defined?(OBJECT_TYPES)
+
+    # Returns the type of the object: :document, :publication, :image or :generic
+    def object_type
+      OBJECT_TYPES[obj_type_code]
+    end
+
+    # Returns true if image? or generic?
+    def binary?
+      [:image, :generic].include? object_type
+    end
+
+    # Returns true if object_type == :image
+    def image?
+      object_type == :image
+    end
+
+    # Returns true if object_type == :generic
+    def generic?
+      object_type == :generic
+    end
+
+    # Returns true if object_type == :publication (for folders)
+    def publication?
+      object_type == :publication
+    end
+
+    # Returns true if object_type == :document
+    def document?
+      object_type == :document
+    end
+
+    # Returns true if this object is active (time_when is in objects time interval)
+    def active?(time_when = nil)
+      return false if !valid_from
+      time_then = time_when || Obj.preview_time
+      valid_from <= time_then && (!valid_until || time_then <= valid_until)
+    end
+
+    # Returns true if this object has edited content.
+    # Note that edited content is not available when Configuration.mode == :live
+    # and edited? will always return false in this case.
+    def edited?
+      (is_edited == 1)
+    end
+
+    # Returns true if this object has released content
+    def released?
+      (is_released == 1)
+    end
+
+    # Returns true if the Obj is suppressed.
+    # A suppressed Obj does not represent an entire web page, but only a part of a page
+    # (for example a teaser) and will not be delivered by the rails application
+    # as a standalone web page.
+    def suppressed?
+      suppress_export == 1
+    end
+
+    # Returns true if the export of the object is not suppressed and the content is active?
+    def exportable?(current_time = nil)
+      !suppressed? && active?(current_time)
+    end
+
+    # Returns the file name to which the Content.file_extension has been appended.
+    def filename
+      extension = ".#{file_extension}" unless file_extension.blank?
+      "#{name}#{extension}"
+    rescue NoMethodError
+      name
+    end
+
+    # Returns an array with the names of groups that are permitted to access this Obj.
+    # This corresponds to the cms permission "permissionLiveServerRead".
+    def permitted_groups
+      attr_dict.permitted_groups
+    end
+
+    # Returns true if this object is the root object.
+    def root?
+      parent_obj_id.nil?
+    end
+
+    has_many :children, :class_name => 'Obj', :foreign_key => 'parent_obj_id'
+    belongs_to :parent, :class_name => 'Obj', :foreign_key => 'parent_obj_id'
+
+    # Returns a list of exportable? children excluding the binary? ones unless :all is specfied.
+    # This is mainly used for navigations.
+    def toclist(*args)
+      return [] unless publication?
+      time = args.detect {|value| value.kind_of? Time}
+      toclist = children.find(:all).select{ |toc| toc.exportable?(time) }
+      toclist = toclist.reject { |toc| toc.binary? } unless args.include?(:all)
+      toclist
+    end
+
+    # Returns the sorted +toclist+, respecting sort order and type of this Obj.
+    def sorted_toclist(*args)
+      list = self.toclist(*args)
+      return [] if list.blank?
+
+      cached_sort_key1 = self.sort_key1
+      cached_sort_type1 = self.sort_type1
+
+      sorted_list =
+        if cached_sort_key1.blank?
+          list.sort { |left_obj, right_obj| left_obj.name <=> right_obj.name }
+        else
+          cached_sort_key2 = self.sort_key2
+          cached_sort_type2 = self.sort_type2
+          cached_sort_key3 = self.sort_key3
+          cached_sort_type3 = self.sort_type3
+
+          list.sort do |left_obj, right_obj|
+            compare = compare_on_sort_key(left_obj, right_obj, cached_sort_key1, cached_sort_type1)
+            if compare == 0 && cached_sort_key2
+              compare = compare_on_sort_key(left_obj, right_obj, cached_sort_key2, cached_sort_type2)
+              if compare == 0 && cached_sort_key3
+                compare = compare_on_sort_key(left_obj, right_obj, cached_sort_key3, cached_sort_type3)
+              end
+            end
+            compare
+          end
+        end
+
+      return self.sort_order == "descending" ? sorted_list.reverse : sorted_list
+    end
+
+    def sort_key1 # :nodoc:
+      self[:sort_key1]
+    end
+
+    def sort_key2 # :nodoc:
+      self[:sort_key2]
+    end
+
+    def sort_key3 # :nodoc:
+      self[:sort_key3]
+    end
+
+    # Returns an Array of all the ancestor objects, starting at the root and ending at this object's parent.
+    def ancestors
+      if parent
+        parent.ancestors + [parent]
+      else
+        []
+      end
+    end
+
+    # Returns the Object with the given name next in the hierarchy
+    # returns nil if no object with the given name was found.
+    def find_nearest(name)
+      obj = self.children.find_by_name(name)
+      return obj if obj and obj.active?
+      parent.find_nearest(name) unless self.root?
+    end
+
+    # Returns the value of the attribute specified by its name.
+    #
+    # Passing an invalid key will not raise an error, but return nil.
+    def [](key)
+      # convenience access to name
+      return name if key.to_sym == :name
+
+      # regular activerecord attributes
+      if @attributes.include?(key.to_s)
+        if key == :valid_from or key == :valid_until or key == :last_changed
+          return as_date(super(key))
+        else
+          return super(key)
+        end
+      end
+
+      # Unknown Obj attributes are delegated to the corresponding instance of AttrDict.
+      begin
+        return (attr_dict.send key)
+      rescue NoMethodError
+      end
+
+      # fallback
+      return nil
+    end
+
+    # Reloads the attributes of this object from the database, invalidates custom attributes
+    def reload
+      super
+      @attr_dict = nil
+      @attr_values = nil
+      @attr_defs = nil
+      self
+    end
+
+    # object_name is a legacy alias to name. Please use name instead, because only name
+    # works with ActiveRecord's dynamic finder methods like find_by_name(...)
+    def object_name
+      name
+    end
+
+    # object_class is a legacy alias to name. Please use obj_class instead, because only obj_class
+    # works with ActiveRecord's dynamic finder methods like find_by_obj_class(...)
+    def object_class
+      obj_class
+    end
+
+    # for binary Objs body_length equals the file size
+    # for non-binary Objs body_length equals the number of characters in the body (main content)
+    def body_length
+      attr_dict.body_length
+    end
+
+    # Override this method to provide an external url
+    # where the content (the body) of this Obj can be downloaded.
+    # The Rails Connector will then use this url when creating links to this Obj.
+    # This is useful when delivering images via a content delivery network (CDN), for example.
+    # Returns nil by default.
+    #
+    # Note: When this method returns an url, the Rails Connector's DefaultCmsController
+    # will redirect to this url instead of delivering this Obj's body.
+    # And the Rails Connector's cms_path and cms_url helpers will link to this url
+    # instead of linking to the Obj.
+    #
+    # Note also that the url will be used regardless of the Obj's permissions, so be careful not
+    # to provide urls that contain unprotected secrets.
+    def body_data_url
+      nil
+    end
+
+    def set_attr_values(dictionary) # :nodoc:
+      @attr_values = dictionary
+      @attr_dict = nil
+    end
+
+    # Returns an instance of AttrDict which provides access to formatted attribute values (i.e. content).
+    # The method uses attr_defs to determine the right formatting depending on the particular field type.
+    def attr_dict # :nodoc:
+      @attr_dict ||= AttrDict.new(self, attr_values, attr_defs)
+    end
+
+    # Returns a nested hash of attribute values.
+    def attr_values # :nodoc:
+      @attr_values ||= fetch_attr_values
+    end
+
+    # Returns a nested hash of attribute definitions.
+    def attr_defs # :nodoc:
+      @attr_defs ||= JSON.parse(read_attribute(:attr_defs) || "{}")
+    end
+
+    # Provides access to field metadata:
+    #
+    # <%= @obj.metadata_for_field(:body_de, :titles, :en) %>
+    #
+    # In addition to the field name, the method takes an arbitrary number of arguments
+    # constituting a path through the nested (hash) structures of the attribute definition (attr_defs).
+    #
+    # If the path doesn't fit the metadata structure, the method returns nil and doesn't raise an exception.
+    #
+    def metadata_for_field(field, *args) # :nodoc:
+      rslt = fiona_fields[field.to_s] || attr_defs[field.to_s]
+      args.each do |key|
+        rslt = rslt[key.to_s] unless rslt.nil?
+      end
+      rslt
+    end
+
+    def last_changed
+      self[:last_changed]
+    end
+
+    def valid_from
+      self[:valid_from]
+    end
+
+    def valid_until
+      self[:valid_until]
+    end
+
+    # deprecated, use file_extension instead
+    def content_type
+      logger.warn "DEPRECATION WARNING: Obj#content_type is deprecated, use file_extension instead"
+      file_extension
+    end
+
+    # Returns the MIME-type as determined from the file_extension - see MIME::Types
+    def mime_type
+      @mime_type ||= compute_mime_type
+    end
+
+    def to_liquid # :nodoc:
+      LiquidSupport::ObjDrop.new(self)
+    end
+
+    def respond_to?(method_id, include_private=false) # :nodoc:
+      if super
+        true
+      elsif %w(_attr_dict _attr_defs _attr_values).include?(method_id.to_s)
+        # prevent infinite recursion when calling "attr_*" below,
+        # since rails checks the absence of an "_attr_*" method internally
+        return false
+      else
+        attr_dict.respond_to?(method_id)
+      end
+    end
+
+    def self.preview_time=(t) # :nodoc:
+      Thread.current[:preview_time] = t
+    end
+
+    def self.preview_time # :nodoc:
+      Thread.current[:preview_time] || Time.now
+    end
+
+    private
+
+    def as_date(value)
+      DateAttribute.parse(value) unless value.nil?
+    end
+
+    # Forwards any unknown method call to a corresponding instance
+    # of AttrDict and thus provides access to object fields, i.e. content.
+    #
+    # In case of an invalid method call, an error is raised.
+    #
+    # Hint: Use [] instead to suppress error messages.
+    def method_missing(method_id, *args)
+      super
+    rescue NoMethodError, NameError
+      # prevent infinite recursion when calling "attr_*" below,
+      # since rails checks the absence of an "_attr_*" method internally
+      raise if %w(_attr_dict _attr_defs _attr_values).include?(method_id.to_s)
+
+      if attr_dict.respond_to?(method_id)
+        attr_dict.send method_id, *args
+      else
+        raise
+      end
+    end
+
+    def fiona_fields
+      @fiona_fields ||=
+        ['name', 'obj_class', 'workflow', 'suppressexport', 'permalink'].inject({}) do |all,field|
+          all.merge! field => {
+            'titles' => {'de' => field.humanize, 'en' => field.humanize},
+            'type' => 'string',
+            'help_texts' => {'de' => field, 'en' => field}
+          }
+        end
+    end
+
+    def compute_mime_type
+      MIME::Types.type_for(file_extension).first.content_type
+    rescue
+      binary? ? "application/octet-stream" : "text/plain"
+    end
+
+    def compare_on_sort_key(left_obj, right_obj, my_sort_key, my_sort_type)
+      left_value = left_obj[my_sort_key]
+      right_value = right_obj[my_sort_key]
+
+      if left_value.nil?
+        1
+      elsif right_value.nil?
+        -1
+      # hardcoded type check needed for speed
+      elsif left_value.is_a?(Time) && right_value.is_a?(Time)
+        left_value <=> right_value
+      else
+        if my_sort_type == "numeric"
+          (left_value.to_i rescue 0) <=> (right_value.to_i rescue 0)
+        else
+          left_value.to_s.downcase <=> right_value.to_s.downcase
+        end
+      end
+    end
+
+    def self.try_type
+      result = yield
+      result if class_of_active_record_descendant(result)
+    rescue NameError, ActiveRecord::ActiveRecordError
+      nil
+    end
+
+  end
+
+end
+