multi-solr 01.01.05

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in multi-solr.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/multi_solr/base_searcher.rb

@@ -0,0 +1,393 @@
+# Basis-Suchmodule für SOLR-Indizies
+
+require 'rsolr'
+require "active_support/core_ext/class/attribute_accessors"
+
+module MultiSolr::BaseSearcher
+
+
+  # Erweitern einer Searcher-Class um Basis-Solr-Funktionen
+  #
+  def self.included(base)
+    base.class_eval do
+
+      cattr_accessor :solr_url                   # String mit der Base-Solr-Url (ohne Core-Anteil!)
+
+      cattr_accessor :result_class do            # die zu nutzende Klasse für das Suchergebnis
+        MultiSolr::SearchResult
+      end
+
+      cattr_accessor :facet_enum_fields do       # Array mit den Namen der Felder, die die Facet-Enum-Methode für Facets nutzen (Felder mit kleinen Wertebereichen)
+        []
+      end
+
+      # der zu verwendende SOLR-Core, wird per default aus dem Klassennamen gebildet
+      # Beispiel:  ContainerSearcher => 'core-container'
+      cattr_accessor(:core_name, :instance_reader => false, :instance_writer => false) do
+        m = self.name.match(/(\w+::)*(\w+)Searcher/)
+        if m
+          c = m[2].downcase
+          name = "core-#{c}"
+        else
+          name = 'core-default'
+        end
+        name
+      end
+
+      attr_accessor :fieldlist                # Field-List (siehe Solr-Doku fl-Parameter), default ist *
+      attr_accessor :facets_only              # wenn true, dann nur Facets ermittlen
+      attr_accessor :without_facets           # wenn true, dann auf Facets verzichten
+      attr_accessor :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)
+
+
+    end
+    base.extend ClassMethods
+  end
+
+
+  module ClassMethods
+
+    def set_solr_url url
+      self.solr_url = url
+    end
+
+    # Setzen des CORE-Namens
+    def set_core_name name
+      self.core_name = name
+    end
+
+    def set_result_class clasz
+      self.result_class = clasz
+    end
+
+
+    # Setzen der Feldnamen, die bei Facetierung die Facet-Enum-Methode des SOLR nutzen sollen
+    def set_facet_enum_fields *field_names
+      self.facet_enum_fields += field_names
+    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 1 Stunde
+    #
+    def cached_list_possible_values fieldname, context=nil, searcher_options=nil, expires_in=1.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, searcher_options
+        # und nun im Cache ablegen
+        MultiSolr.logger.debug "#{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
+
+
+    # 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
+    #  searcher_options: optinale Hash mit Optionen für den hier intern erzeugten Searcher (see self.initialize)
+    # Beispiel:
+    #   searcher.list_possible_values :lkz, :whs_id => 5
+    #
+    def list_possible_values fieldname, context=nil, searcher_options=nil
+      s_request = MultiSolr::SearchRequest.new :facets => [fieldname]
+      searcher_options ||= {}
+      searcher = self.new(searcher_options.merge(:facets_only => true))
+      result = searcher.execute(s_request, context)
+      facet_counts = result.facet_counts
+      values = []
+      if MultiSolr.logger.debug?
+        MultiSolr.logger.debug "#{name}.list_possible_values(#{fieldname}, #{context.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 "#{name}.list_possible_values(#{fieldname}, #{context.inspect}) => #{values.inspect}"
+      end
+      values
+    end
+
+
+    # Liefert RSolr-Connection (RSolr.connect) zum konfigurierten SOLR-Server(see solr_url)
+    # und konfiguriertem Core (see core_name)
+    def solr_connection
+      url = self.solr_url || raise("no solr-url configured!")
+      url = "#{url}/#{self.core_name}" if self.core_name
+      MultiSolr.logger.debug("solr_connection: url==#{url}")
+      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
+
+
+    # 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 => 900) 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
+
+  end
+  # ===== ENDE der Class-Methods =====
+
+
+
+  # ===== START Instance-Methods =====
+
+
+  # Constructor
+  # params:
+  #  options: optionaler Hash mit Options (als Option sind aller hier definierten Attribute erlaubt)
+  def initialize options=nil
+    if options
+      options.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+  end
+
+  # liefert lokalen Core-Namen und wenn nicht gesetzt den globalen Core-Namen (in der Klasse definierten)
+  def core_name
+    @core_name || self.class.core_name
+  end
+
+
+  # setzt lokalen Core-Namen ohne den globalen Core-Namen (in der Klasse definiert) zu ändern
+  def core_name=(name)
+    @core_name = name
+  end
+
+
+  # liefert SOLR-Connection
+  def solr_connection
+    return @solr_connection if @solr_connection
+    url = self.class.solr_url || raise("no solr-url configured!")
+    url = "#{url}/#{self.core_name}" if self.core_name
+    MultiSolr.logger.debug("solr_connection: url==#{url}")
+    @solr_connection = RSolr.connect :url => url
+  end
+
+
+
+  # Ausführen der Suche / Recherche
+  # params:
+  #   solr_search_request: die Suchanfrage als SolrSearchRequest-Instance
+  #   context: Hash mit weiteren Context-Informationen, dieser wird u.a. an den Force-Query-Builder übergeben
+  def execute solr_search_request, context=nil
+    solr_params = build_solr_params solr_search_request, context
+    solr_result = solr_connection.get 'select', :params => solr_params
+
+    # RAW-Result liefern wenn Result-Format gesetzt ist
+    return solr_result if self.result_format
+
+    # Parsen des Ergebnisses
+    result = self.result_class.new solr_result, solr_search_request, context
+    result
+  end
+
+
+  # Bilden der SOLR-Parameter für eine SOLR-Anfrage
+  # params:
+  #   solr_search_request: die Suchanfrage als SolrSearchRequest-Instance
+  #   context: Hash mit weiteren Context-Informationen, dieser wird an den Force-Query-Builder übergeben
+  # returns: Hash mit den SOLR-Parametern
+  def build_solr_params solr_search_request, context=nil
+    solr_params = {}
+    solr_params['stats.field'] = []
+
+    fq_params = self.force_query_params 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 self.fieldlist
+        self.fieldlist << ',score' unless self.fieldlist[',score']
+      else
+        self.fieldlist = '*,score'
+      end
+    end
+    solr_params[:fl] = self.fieldlist if self.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 !self.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 self.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] = self.result_format if self.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)
+          field_facet_params['method'] = 'enum' if self.facet_enum_fields.include?(facet_field)
+
+          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

data/lib/multi_solr/filter_value_composite.rb

@@ -0,0 +1,33 @@
+# Composite-Klasse von Filter und Filter-Value
+
+class MultiSolr::FilterValueComposite
+
+  attr_accessor :filter
+  attr_accessor :value
+
+  # Constructor
+  # Params:
+  #   filter: konkrete Filter-Instance (i.a. ein MultiSolr::SolrFilterSimple oder eine Subklasse davon)
+  #   value:  aktueller Wert für diesen Filter (String oder Hash)
+  def initialize filter, value=nil
+    @filter = filter
+    @value = value
+  end
+
+  # delegate der Methode 'render_value' an den Filter unter Nutzung des hinterlegten Wertes
+  def render_value
+    @filter.render_value @value
+  end
+
+  # delegate der Methode 'render_for_semantic_form' an den Filter unter Nutzung des hinterlegten Wertes
+  def render_for_semantic_form sform, context=nil, form_input_options={}
+    @filter.render_for_semantic_form sform, @value, context, form_input_options
+  end
+
+
+  # delegate der Methode 'build_solr_query' an den Filter unter Nutzung des hinterlegten Wertes
+  def build_solr_query
+    @filter.build_solr_query @value
+  end
+
+end

data/lib/multi_solr/rails_form_render_helper.rb

@@ -0,0 +1,84 @@
+module MultiSolr::RailsFormRenderHelper
+
+
+  # Generieren der HML-Form-Felder (input/select/..) für den angegeben Filter
+  # Params:
+  #   form:         das Rails-Form-Object, dieses MUSS als Object eine MultiSolr::SearchRequest-Instance haben
+  #   filter_name:  Name des Filters als Symbol (die SearchRequest-Instance im Form muss diesen Filter kennen)
+  #   options:      optionale Formular-Input-Feld-Options. Beschreibung => siehe jeweilige Beschreibung je Filter-Methode
+  #                 Diese werden i.d.R. an die Rails-Form-Methode 'text_field' weitergegeben.
+  #
+  # returns:  HTML-Code des Input-Feldes als String
+  def render_solr_filter_for_form form, filter_name, options={}
+    cur_options = options.clone
+    search_request = form.object
+    filter = search_request.class.possible_filters[filter_name]
+    raise "unknown filter: #{filter_name}" if filter.nil?
+    label = cur_options.delete(:label) || filter.label
+    render_method = "render_#{filter.class.to_s.underscore}"
+    render_method.gsub!("/", '_')
+    render_method.gsub!("multi_solr_", '')
+    "<label>#{label}</label>".html_safe + send(render_method, form, filter, cur_options)
+  end
+
+
+  # generiert für einen SolrFilterSimple einen input-tag vom typ text
+  # mit der css-class "simple"
+  def render_solr_filter_simple form, filter, options
+    add_class options, 'simple'
+    form.text_field "filter_#{filter.name}", options
+  end
+
+
+  # generiert für einen SolrFilterSimple einen input-tag vom typ text
+  # mit der css-class "datepicker"
+  # Diese css-Klasse kann dann als jQuery-Selector für datepicker genutzt werden
+  def render_solr_filter_date form, filter, options
+    add_class options, 'datepicker'
+    form.text_field "filter_#{filter.name}", options
+  end
+
+
+  def render_solr_filter_date_range form, filter, options
+    add_class options, 'datepicker'
+    value = form.object.send("filter_#{filter.name}")
+    return nil if value.blank? || !value.is_a?(Hash) || value.empty?
+    from = value["#{filter.name}_from"]
+    to = value["#{filter.name}_to"]
+    date_range = Struct.new("#{filter.name}_from".to_sym, "#{filter.name}_to".to_sym).new from,to
+    form.fields_for "filter_#{filter.name}", date_range do |fields_form|
+      fields_form.template.concat("<label>ab</label>".html_safe)
+      fields_form.template.concat(fields_form.text_field("#{filter.name}_from", options))
+      fields_form.template.concat("<label>bis</label>".html_safe)
+      fields_form.template.concat(fields_form.text_field("#{filter.name}_to", options))
+    end
+  end
+
+
+
+  def render_solr_filter_collection form, filter, options
+    add_class options, 'collection'
+    core_handler = options.delete(:core_handler)
+    context = options.delete(:context)
+    data = filter.collection_data(core_handler, context)
+    form.select "filter_#{filter.name}", data, options
+  end
+
+
+  def render_solr_filter_free_query form, filter, options
+    add_class options, 'free_query'
+    form.text_field "filter_#{filter.name}", options
+  end
+
+
+  private
+
+
+  def add_class options, css_class_name
+    css_class = options[:class]
+    css_class = css_class.nil? ? css_class_name : "#{css_class} #{css_class_name}"
+    options[:class] = css_class
+  end
+
+
+end