multi-solr 01.01.05

data/lib/multi_solr/search_request.rb

@@ -0,0 +1,209 @@
+# Solr-Suchanfrage
+# Diese enthält einmal die möglichen Suchfilter und die konkreten Such-Werte
+# sowie  andere Suchparameter (Paginierung etc.)
+
+class MultiSolr::SearchRequest
+
+  # Array(String) mit den Feldnamen zu denen eine Facet gebildet werden soll 
+  attr_accessor :facets           
+
+  # Hash mit optionalen Parametern zur Facet-Bildung
+  # z.B. {:lagerort_h => {:limit => 1000, :sort => :index},
+  #       :mdate => {:range => true, :start => 'NOW/DAY-5Day', :end => 'NOW/DAY', :gap => '+1DAY'},
+  #       :saison => {:stats_field => 'volumen'}}
+  attr_accessor :facet_params
+
+  attr_accessor :sorts            # Array(String) mit den Feldnamen für die Sortierung (optional mit Sortierrichtung)
+  attr_accessor :stats_fields     # Array(String) mit den Feldnamen für die Gesamt-Statistiken berechnet werden sollen (Summe, min, max,...)
+  attr_accessor :group_field      # Name des Feldes nach dem gruppiert werden soll. Wenn nil, dann erfolgt keine Gruppierung(default)
+  attr_accessor :group_size       # Anzahl der Ergebnisse je Gruppe, wenn nil so ist laut SOLR default=1
+  attr_accessor :group_truncate   # wenn true, dann werden Facets auf Basis der Gruppierung gebildet
+  attr_reader   :filter_values    # Hash(Symbol => String,Hash) mit den konkreten Filter-Werten
+  attr_writer   :page_size        # angeforderte Anzahl Einträge je Seite
+  attr_accessor :active_filters   # Array mit den Namen der aktiven Filter (als Symbole)
+
+  @default_page_size = 25
+
+  BASE_FILTER_MAP = { :simple     => MultiSolr::SolrFilterSimple,
+                      :collection => MultiSolr::SolrFilterCollection,
+                      :date_range => MultiSolr::SolrFilterDateRange,
+                      :date       => MultiSolr::SolrFilterDate,
+                      :free_query => MultiSolr::SolrFilterFreeQuery
+                    }
+
+  class << self
+
+    # Definieren eines Filters
+    # Erzeugt für den Filter entsprechende Attribut-Methoden
+    # Dies vereinfacht die Nutzung in Formularen
+    # Z.B. für einen Filter mit den Namen :firma_nr werden die Methoden
+    # filter_firma_nr und filter_firma_nr=(value) generiert
+    #
+    # Params:
+    #   filter_name: Name des Filters als Symbol
+    #   options:     optionale Hash mit:
+    #     :type      Typ des Filters, entweder Typ-Bezeichner ein Symbol oder die Klasse des Filters
+    #                Der Typ-Bezeichner muss in MultiSolr::SearchRequest::BASE_FILTER_MAP definiert sein.
+    #                Ist kein Type angegeben so wird
+    #    andere:     Alle anderen Angaben in den Options werden an den Filter weitergereicht.
+    #                Siehe also dazu die Beschreibungen am Constructor der einzelnen Filtertypen
+    #
+    def define_filter filter_name, options={}
+      @possible_filters ||= {}
+      filter_type = options.delete(:type) || :simple
+      if filter_type.is_a?(Symbol)
+        # Zum Symbol die konkrete Filterklasse holen
+        filter_type = BASE_FILTER_MAP[filter_type]
+        raise "Unknown type: #{filter_type}" if filter_type.nil?
+      end
+      filter = filter_type.new filter_name, options
+      @possible_filters[filter_name] = filter
+
+      # Definieren der Methode zum Lesen des Values dieses Filters
+      define_method "filter_#{filter_name}" do
+        @filter_values[filter_name]
+      end
+      #
+      # Definieren der Methode zum zuweisen des Wertes dieses Filters
+      define_method "filter_#{filter_name}=" do |value|
+        if value.blank? || (value.is_a?(Array) && (value.empty? || value.all?(&:blank?)) ) || (value.is_a?(Hash) && value.values.all?(&:blank?))
+          @active_filters.delete(filter_name)
+          return
+        end
+        @filter_values[filter_name] = value
+        @active_filters << filter_name unless @active_filters.include?(filter_name)
+      end
+    end
+
+    # mögliche Filter (Hash Filtername(Smybol) => Filter(SolrFilterSimple-Instance))
+    def possible_filters
+      @possible_filters || {}
+    end
+
+
+    def set_default_page_size size
+      @default_page_size = size
+    end
+
+    def default_page_size
+      @default_page_size
+    end
+
+  end # of Class-Methods
+
+  
+
+  # Create new SolrSearch-Instance
+  # @param attributes mit den Attributewerten als Hash (optional)
+  def initialize attributes=nil
+    @filter_values = {}
+    @active_filters = []
+    @sorts = []
+    @facets = []
+    if attributes.is_a? Hash
+      attributes.each do |aname, value|
+        m_name = "#{aname}="
+        send(m_name, value) if self.respond_to?(m_name)
+      end
+    end
+  end
+
+
+  # Erzeugen ein FilterValue-Composite-Object welches
+  # aus dem Filter und den in @filter_values hinterlegten Wert erzeugt wird
+  # params:
+  #   filter_name: Name des Filters als Symbol
+  # returns: MultiSolr::FilterValueComposite-Instance mit dem Filter und den zugehörigen Wert
+  def build_filter_value_composite filter_name, value=nil
+    filter = self.class.possible_filters[filter_name]
+    raise "Unknown filter: #{filter_name}" if filter.nil?
+    value ||= @filter_values[filter_name]
+    MultiSolr::FilterValueComposite.new filter, value
+  end
+
+  
+  # Erzeugt aus den filter_values die Solr-Query
+  # liefert die Query als String
+  def build_query
+    solr_queries = []
+    @filter_values.each do |fname, value|
+      fa_composite = build_filter_value_composite fname, value
+      solr_query = fa_composite.build_solr_query
+      solr_queries << solr_query unless solr_query.blank?
+    end
+    solr_queries.join(' ')
+  end
+
+
+  def render_filter_description
+    descriptions = []
+    @filter_values.each do |fname, value|
+      filter = self.class.possible_filters[fname]
+      raise "Unknown filter: #{fname}" if filter.nil?
+      value = filter.render_value value
+      descriptions << "#{filter.label} = #{value}"
+    end
+    descriptions
+  end
+
+
+  # Filter mit konkreten Wert belegen
+  def set_filter filter_name, value
+    filter_name = filter_name.to_sym
+    raise "Unbekannter Filter'#{filter_name}'" unless self.class.possible_filters.has_key?(filter_name)
+    @filter_values[filter_name] = value
+    @active_filters << filter_name unless @active_filters.include?(filter_name)
+  end
+
+
+  def remove_facet facet_name
+    @facets.delete(facet_name.to_s) if @facets
+  end
+
+
+  def page= page_nr
+    @page = [1, page_nr.to_i].max
+  end
+
+  def page
+    @page || 1
+  end
+
+  def page_size
+    @page_size || self.class.default_page_size
+  end
+
+
+  def possible_filter_keys
+    self.class.possible_filters.keys
+  end
+
+  # liefert Liste der möglichen Filternamen incl. der Labels
+  # sortiert nach Labels
+  # als Array aus Tuples
+  # z.B. [ [:firma_nr, 'Bestandsfirma'], [:lkz, 'LKZ'] ]
+  def possible_filter_keys_sorted_with_labels
+    keys = self.class.possible_filters.keys
+    result = keys.map{|k| [k, I18n.t("solr_search.#{k}")]}
+    result.sort!{|e1,e2| e1.last <=> e2.last}
+    result
+  end
+
+  # Liefert die Liste der inactiven Filter
+  # (possible-filters - active-filters)
+  # returns Array of Symbols
+  def inactive_filters
+    self.class.possible_filters.keys - @active_filters
+  end
+
+  # Abbilden von 3 Sortiermöglichkeiten als sort1 ... sort3
+  (1..3).each do |i|
+    define_method "sort#{i}" do
+      @sorts[i-1]
+    end
+
+    define_method "sort#{i}=" do |value|
+      @sorts[i-1] = value
+    end
+  end
+end

data/lib/multi_solr/search_result.rb

@@ -0,0 +1,127 @@
+# Ergebnis der SolR-Suche
+
+
+class MultiSolr::SearchResult
+
+  attr_reader :hits,           # Integer mit Anzahl der Treffer
+              :hits_grouped,   # Anzahl der Treffer über alle Gruppen (nur bei Suche mit Gruppierung)
+              :metadata,       # Hash mit Metadaten so wie sie vom SolR kommen (QTime u.a.)
+              :facet_fields,   # Hash(String,Array) mit Facet-Fields-Daten wenn angefordert
+              :facet_ranges,   # Hash(String,Array) mit Facet-Range-Daten wenn angefordert
+              :stats,          # Hash mit Stats-Daten wenn angefordert
+              :stats_facets,   # Hash mit Stats-Facet-Werten (wenn Facets über Stats-Componente gebildet wurden)
+              :solr_result,    # Original Solr-Result
+              :search_request  # Original SearchRequest
+
+  attr_accessor :data_rows # Array(Hash) mit den gefundenen Daten-Zeilen
+
+
+  # Params:
+  #   solr_result:          Hash, so wie sie direkt vom SolR kommt
+  #   solr_search_request:  der zugehörige Such-Request (eine Instance von MultiSolr::SearchRequest)
+  #   context:              Context-Inforamtionen, so wie sie bei der Suchausführung angegeben wurden (siehe MultiSolr::BaseSearcher#execute)
+  def initialize solr_result, solr_search_request, context
+    @solr_result = solr_result
+    @search_request = solr_search_request
+    @context = context
+    if solr_result['grouped']
+      parse_grouping_result
+    else
+      parse_non_grouping_result
+    end
+
+    if @hits && @hits > 0
+      parse_stats if solr_result.key?('stats')
+      parse_facet_counts
+    end
+  rescue => ex
+    MultiSolr.logger.warn "#{self.class.name}.initialize: #{ex}\n\t"+ex.backtrace[0..10].join("\n\t")
+    MultiSolr.logger.warn solr_result.inspect
+  end
+
+
+  # Mapper facet_fields => facet_counts wegen Abwärtskompatibilität
+  def facet_counts
+    @facet_fields
+  end
+
+  def page
+    @search_request.page
+  end
+
+  def total_pages
+    return @_total_pages if @_total_pages
+    @_total_pages, rest = @hits.divmod(@search_request.page_size)
+    @_total_pages += 1 if rest > 0
+    @_total_pages
+  end
+
+
+  # Paginierung der Result-Docs als WillPaginate::Collection
+  # Achtung! Dies bedingt das Gem "willpaginate". Dieses ist nicht als Abhängikeit definiert
+  def paginate_result
+    return if @data_rows.nil? || @data_rows.empty?
+    @data_rows = WillPaginate::Collection.create(@search_request.page, @search_request.page_size) do |pager|
+      pager.replace(@data_rows)
+      pager.total_entries = @hits
+    end
+  end
+
+
+  private
+
+
+  def parse_non_grouping_result
+    @metadata = @solr_result['response']
+    if @metadata
+      @data_rows = @metadata.delete('docs')
+      @metadata.merge!(@solr_result['responseHeader'])
+      @hits = @metadata['numFound'].to_i
+    end
+  end
+
+
+  def parse_grouping_result
+    @metadata = @solr_result['responseHeader']
+    grouped_data = @solr_result['grouped'][@search_request.group_field]
+    @data_rows = grouped_data['groups']
+    @hits = grouped_data['ngroups'].to_i
+    @hits_grouped = grouped_data['matches'].to_i
+  end
+
+
+  def parse_facet_counts
+    solr_facet_counts = @solr_result['facet_counts']
+    if MultiSolr.logger.debug?
+      MultiSolr.logger.debug "parse_facet_counts: #{solr_facet_counts.inspect}"
+    end
+    return if solr_facet_counts.nil?
+    @facet_fields = solr_facet_counts['facet_fields']
+    @facet_ranges = solr_facet_counts['facet_ranges']
+  end
+
+
+  def parse_stats
+    @stats = solr_result['stats']['stats_fields']
+    return if @stats.nil?
+    # Parsen der evtl. Stats-Facets
+    @stats.each do |stats_field, values|
+      # z.B.: stats_field : 'volumen', values : {min : xxx, ..., facets : {...} }
+      facets = values['facets']
+      next if facets.nil?
+      @stats_facets ||= {}
+      facets.each do |facet, facet_values|
+        # z.B.: facet : 'saison', facet_values: { '125': {min:xxx, sum:xx, ....}, '121': {min:xxx, sum:xx, ....}}
+        @stats_facets[facet] ||= {}
+        stats_facet = @stats_facets[facet]
+        facet_values.each do |facet_entry, entry_values|
+          # z.B: facet_entry : '125', entry_values : {min:xxx, sum:xx, ....}
+          # Dies wird nun umgemapt auf facet : facet_entry : stats_field : entry_values
+          stats_facet[facet_entry] ||= {}
+          stats_facet[facet_entry][stats_field] = entry_values
+        end
+      end
+    end
+  end
+
+end

data/lib/multi_solr/single_core_handler.rb

@@ -0,0 +1,341 @@
+# Basis-Klasse für das Handling von SOLR-Indizies (sogenannte SOLR-Cores)
+
+require 'rsolr'
+
+class MultiSolr::SingleCoreHandler
+
+  attr_reader   :solr_url                 # String mit der Base-Solr-Url (ohne Core-Anteil!)
+  attr_accessor :core_name                # der zu verwendende SOLR-Core
+  attr_accessor :result_class             # die zu nutzende Klasse für das Suchergebnis
+  attr_accessor :facet_enum_fields        # Array mit den Namen der Felder, die die Facet-Enum-Methode für Facets nutzen (Felder mit kleinen Wertebereichen)
+  attr_accessor :default_search_options   # Hash mit weiteren Optionen für Query Anfragen (fieldlist,..) siehe params bei der Methode search
+
+
+  # Erzeugen neuen Core-Handler
+  # Parameter:
+  #   solr_url :               String mit der Base-Solr-Url (ohne Core-Anteil!)
+  #   core_name :              der zu verwendende SOLR-Core
+  #   options: optionaler Hash mit folgenden Werten:
+  #     :result_class :           die zu nutzende Klasse für das Suchergebnis, default ist MultiSolr:SearchResult
+  #     :facet_enum_fields :      Array mit den Namen der Felder,
+  #                               die die Facet-Enum-Methode für Facets nutzen
+  #                               (Felder mit kleinen Wertebereichen)
+  #     :default_search_options : Hash mit weiteren Optionen für Query Anfragen:
+  #         :fieldlist            Field-List (siehe Solr-Doku fl-Parameter), default ist alle Felder
+  #         :facets_only          wenn true, dann nur Facets ermittlen
+  #         :without_facets       wenn true, dann auf Facets verzichten
+  #         :result_format        Rückgabe-Format (json, xml),
+  #                               wenn nicht gesetzt wird "ruby" geliefert;
+  #                               Ist es gesetzt wird das Ergebnis nicht geparst (also raw als String zurückgegeben)
+  def initialize solr_url, core_name, options=nil
+    @solr_url = solr_url || raise("No 'solr_url' given!")
+    @core_name = core_name
+    if options
+      options.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    @result_class ||= MultiSolr::SearchResult
+    @default_search_options ||= {}
+  end
+
+
+  # Liefert RSolr-Connection (RSolr.connect) zum konfigurierten SOLR-Server(see solr_url)
+  # und konfiguriertem Core (see core_name)
+  def solr_connection
+    url = "#{@solr_url}/#{@core_name}"
+    MultiSolr.logger.debug("solr_connection: url==#{url}") if MultiSolr.logger.debug?
+    RSolr.connect :url => url
+  end
+
+
+  # sendet Ping an SOLR-Instance
+  # returns true if ok
+  def ping
+    self.solr_connection.head("admin/ping").response[:status] == 200
+  end
+
+
+
+  # Liefert zu dem spezifizierten Kontext und Feld die möglichen Werte
+  # Parameter:
+  #  fieldname: Name des Feldes (als Symbol)
+  #  context:   optionales Object mit weiteren Context-Informationen, dieser wird an den Force-Query-Builder übergeben
+  #  search_request: optional bestehendes SearchRequest (für DrillDown-Funktionalität)
+  # Beispiel:
+  #   searcher.list_possible_values :lkz, :whs_id => 5
+  #
+  def list_possible_values fieldname, context=nil, search_request=nil
+    search_request ||= MultiSolr::SearchRequest.new
+    search_request.facets = [fieldname]
+    result = search(search_request, :context => context, :facets_only => true)
+    facet_counts = result.facet_counts
+    values = []
+    if MultiSolr.logger.debug?
+      MultiSolr.logger.debug "#{self.class.name}.list_possible_values(#{fieldname}, #{context.inspect}, #{search_request.inspect}): facet_counts=#{facet_counts.inspect}"
+    end
+    if facet_counts
+      value_pairs = facet_counts[fieldname.to_s]
+      if value_pairs && !value_pairs.empty?
+        # das value_pairs besteht Paar-weise aus Value und Anzahl
+        # Es werden hier nur die Values gebraucht, wo die Anzahl >0 ist
+        value_pairs.each do |value_count_pair|
+          val, count = value_count_pair
+          if val && count > 0
+            # wenn val nur aus Zahlen besteht, dann nach Integer konvertieren (wegen der Sortierung)
+            val = val.to_i if val =~ /\d+/
+            values << val
+          end
+        end
+        values.sort!
+      end
+    end
+    if MultiSolr.logger.debug?
+      MultiSolr.logger.debug "#{self.class.name}.list_possible_values(#{fieldname}, #{context.inspect}) => #{values.inspect}"
+    end
+    values
+  end
+
+
+  # Ermittelt und cached die möglichen Werte der als pre_cache_value_fields definierten Felder
+  # Diese werden im Rails-Cache zwischengespeichert
+  # Ansonsten see BaseSearcher.list_possible_values
+  # zusätzlicher Parameter:
+  #   expires_in:  optional, Gültigkeit des Cache-Wertes in Sekunden, default ist 3 Stunden
+  #
+  def cached_list_possible_values fieldname, context=nil, expires_in=3.hours
+    cache_key = "solr-#{self.core_name}-#{context}-#{fieldname}-values"
+    values = MultiSolr.cache.read(cache_key)
+    if values.nil?
+      # dann sind noch gar keine Werte gecached => diese holen
+      values = list_possible_values fieldname, context
+      # und nun im Cache ablegen
+      MultiSolr.logger.debug "#{self.class.name}.cached_list_possible_values: write in cache '#{cache_key}' => #{values.inspect}" if MultiSolr.logger.debug?
+      MultiSolr.cache.write(cache_key, values, :expires_in => expires_in)
+    end
+    values
+  end
+
+
+
+
+  # ermitteln Zeitstempel des letzten Datenimports
+  def import_status solr_core_import_handler_propfile_path
+    MultiSolr.cache.fetch("Solr.import_status.#{self.core_name}.#{solr_core_import_handler_propfile_path}", :expires_in => 1.hours) do
+      result = 'unbekannt'
+      begin
+        raise("Solr-Import-Status-Propertiesfile not exist") unless File.exist?(solr_core_import_handler_propfile_path)
+        matcher = /^last_index_time=(.*)$/
+        data = File.read(solr_core_import_handler_propfile_path)
+        match = matcher.match(data)
+        if match
+          result = match[1]
+          result.gsub!('\\', '') # Zeit enthält \ vor :
+          result = result[0...-3] # Sekunden entfernen
+        end
+      rescue => ex
+        MultiSolr.logger.warn "SolrSearch.import_status: source=#{solr_core_import_handler_propfile_path}, error=#{ex.message}\n\t"+ex.backtrace.join("\n\t")
+      end
+      MultiSolr.logger.info "SolrSearch.import_status: #{solr_core_import_handler_propfile_path}, result=#{result}"
+      result
+    end
+  end
+
+
+  # liefert einzelnes Solr-Dokument an Hand der Id
+  # Parameter:
+  #   id:             die gewünschte Id (Integer oder String)
+  #   id_field_name : optional, der Name des ID-Fields, default ist 'id'
+  def get_doc_by_id(id, id_field_name=:id)
+    solr_result = solr_connection.get 'select', :params => {:q => "#{id_field_name}:#{id}", :rows => 1}
+    docs = solr_result['response']['docs']
+    return nil if docs.nil? || docs.empty?
+    docs.first
+  end
+
+
+
+
+  # Ausführen der Suche / Recherche
+  # params:
+  #   solr_search_request : die Suchanfrage als SolrSearchRequest-Instance
+  #   options :     Hash mit weiteren Optionen für Query Anfragen:
+  #     :context :            Hash mit weiteren Context-Informationen, dieser wird u.a. an den Force-Query-Builder übergeben
+  #     :fieldlist            Field-List (siehe Solr-Doku fl-Parameter), default ist *
+  #     :facets_only          wenn true, dann nur Facets ermittlen
+  #     :without_facets       wenn true, dann auf Facets verzichten
+  #     :result_format        Rückgabe-Format (json, xml),
+  #                           wenn nicht gesetzt wird "ruby" geliefert;
+  #                           Ist es gesetzt wird das Ergebnis nicht geparst (also raw als String zurückgegeben)
+  def search solr_search_request, options=nil
+    used_options = @default_search_options.clone
+    used_options.merge! options if options
+
+    solr_params = build_solr_params solr_search_request, used_options
+    solr_result = solr_connection.get 'select', :params => solr_params
+
+    # RAW-Result liefern wenn Result ein String ist
+    return solr_result if solr_result.is_a? String
+
+    # Parsen des Ergebnisses
+    result = self.result_class.new solr_result, solr_search_request, used_options[:context]
+    result
+  end
+
+
+  # Bilden der SOLR-Parameter für eine SOLR-Anfrage
+  # params:
+  #   solr_search_request: die Suchanfrage als SolrSearchRequest-Instance
+  #   options: siehe search
+  # returns: Hash mit den SOLR-Parametern
+  def build_solr_params solr_search_request, options
+
+    solr_params = {}
+    solr_params['stats.field'] = []
+
+    fq_params = self.force_query_params options[:context]
+    if fq_params && fq_params.is_a?(Hash)
+      fq = []
+      fq_params.each{|k, v| fq << "#{k}:#{v}"}
+      solr_params[:fq] = fq.join(' ')
+    end
+
+    q = solr_search_request.build_query
+    q = "*:*" if q.blank? # wenn keine Query angegeben ist, dann nach allem Suchen
+    solr_params[:q] = q
+
+    # Fieldlist
+    if q['_val_:']
+      # dann enthält die Query eine query-function
+      # Der Wert dieser wird immer im field "score" abgelegt
+      # daher dieses Feld zur Feldliste hinzufügen
+      if options[:fieldlist]
+        options[:fieldlist] << ',score' unless self.fieldlist[',score']
+      else
+        options[:fieldlist] = '*,score'
+      end
+    end
+    solr_params[:fl] = options[:fieldlist] if options.key? :fieldlist
+
+    # Sortierung
+    if solr_search_request.sorts && !solr_search_request.sorts.empty?
+      solr_search_request.sorts.delete_if{|s| s.blank?}
+      solr_params[:sort] = solr_search_request.sorts.map{|s| s =~ /\s(asc|desc)$/ ? s : "#{s} asc"}.join(',')
+    end
+
+    # Facets
+    if !options[:without_facets] && solr_search_request.facets
+      parse_facets solr_search_request, solr_params
+    end
+
+    # Stats
+    if solr_search_request.stats_fields && !solr_search_request.stats_fields.empty?
+      s_fields = solr_search_request.stats_fields.select{|f| !f.blank?}
+      unless s_fields.empty?
+        solr_params[:stats] = true
+        solr_params['stats.field'] += s_fields
+      end
+    end
+    solr_params['stats.field'].map!{|f| f.to_s}.uniq!
+
+    # Gruppierung
+    if !solr_search_request.group_field.blank? && !self.facets_only
+      solr_params[:group] = true
+      solr_params['group.field'] = solr_search_request.group_field
+      solr_params['group.ngroups'] = true
+      solr_params['group.limit'] = solr_search_request.group_size || 1
+      solr_params['group.truncate'] = true if solr_params[:facet] && solr_search_request.group_truncate
+    end
+
+
+    # Paginierung
+    if options[:facets_only]
+      solr_params[:rows] = 0
+    else
+      solr_params[:rows] = solr_search_request.page_size
+      solr_params[:start] = (solr_search_request.page-1) * solr_search_request.page_size
+    end
+
+    # Ausgabe-Format
+    solr_params[:wt] = options[:result_format] if options.key? :result_format
+
+    if MultiSolr.logger.debug?
+      MultiSolr.logger.debug "SolrSearch#build_solr_params: #{self.inspect}\n\tSEARCH-REQUEST=#{solr_search_request.inspect}\n\t=> SOLR_PARAMS=#{solr_params.inspect}\n"
+    end
+    solr_params
+  end
+
+
+  protected
+
+  # liefert wenn notwendig die Parameter als Hash für eine SOLR-Force-Query
+  # sollte bei Bedarf von der nutzenden Klasse überschrieben werden.
+  # params:
+  #   context: Hash mit weiteren Context-Informationen
+  def force_query_params context
+    context
+  end
+
+
+  private
+
+
+  # Bilden der Facet-Solr-Params aus den Facet-Definitionen des Requests
+  def parse_facets solr_search_request, solr_params
+    solr_search_request.facets.delete_if(&:blank?) # leer Elemente entfernen
+    return if solr_search_request.facets.empty?
+
+    solr_params['facet.field'] = []
+    solr_params['facet.range'] = []
+    facet_params = solr_search_request.facet_params || {}
+    solr_search_request.facets.map(&:to_sym).each do |facet_field|
+      field_facet_params = facet_params[facet_field] || {}
+      stats_facet_field = field_facet_params[:stats_field]
+      if stats_facet_field
+        # dann Facet per Stats-Componente
+        solr_params[:stats] = true
+        if stats_facet_field.is_a?(Array)
+          solr_params['stats.field'] += stats_facet_field
+        else
+          solr_params['stats.field'] << stats_facet_field
+          stats_facet_field = [stats_facet_field]
+        end
+        stats_facet_field.each do |sfield_name|
+          solr_params["f.#{sfield_name}.stats.facet"] ||= []
+          solr_params["f.#{sfield_name}.stats.facet"] << facet_field
+        end
+      else
+        solr_params[:facet] = true
+        if field_facet_params[:range]
+          # Range-Facet
+          solr_params[:facet] = true
+          solr_params['facet.range'] << facet_field
+          field_facet_params[:end] ||= 'NOW/DAY'
+          field_facet_params[:gap] ||= '+1DAY'
+          field_facet_params.each do |option_name, value|
+            solr_params["f.#{facet_field}.facet.range.#{option_name}"] = value
+          end
+        else
+          # normale Facet-Field
+          solr_params['facet.field'] << facet_field
+          field_facet_params[:mincount] ||= 1 # Facets ohne Treffer ignorieren
+                                        # Nutzen der Facet-Enum-Methode fuer spezielle Felder (Felder mit kleinen Wertebereichen)
+          if self.facet_enum_fields && self.facet_enum_fields.include?(facet_field)
+            field_facet_params['method'] = 'enum'
+          end
+
+          field_facet_params.each do |option_name, value|
+            solr_params["f.#{facet_field}.facet.#{option_name}"] = value
+          end
+        end
+      end
+    end
+    if solr_params[:facet]
+      # Umschalten der Facet-Ergebnisse in Array-Darstellung
+      # (der json.nl-Schalter wirkt auch bei Ruby siehe http://wiki.apache.org/solr/SolJSON)
+      solr_params['json.nl'] = 'arrarr'
+    end
+
+  end
+
+end