infopark_fiona_connector 7.0.1.5.2.3.rc8

data/lib/rails_connector/link_list.rb

@@ -0,0 +1,28 @@
+module RailsConnector
+  # @api public
+  class LinkList < Array
+    def initialize(link_definitions)
+      if link_definitions.blank?
+        super([])
+      else
+        super(build_links(link_definitions.map(&:symbolize_keys)))
+      end
+    end
+
+    # @api public
+    def destination_objects
+      map { |link| link.destination_object }.compact
+    end
+
+    private
+
+    def build_links(link_definitions)
+      object_ids = link_definitions.map { |link_data| link_data[:destination] }.compact.uniq
+      objects = object_ids.empty? ? [] : Obj.find(object_ids)
+      link_definitions.each_with_object([]) do |link_data, links|
+        link = Link.new(link_data, objects.detect { |o| o && o.id == link_data[:destination] })
+        links << link if link.active?
+      end
+    end
+  end
+end

data/lib/rails_connector/link_resolvable.rb

@@ -0,0 +1,5 @@
+module RailsConnector
+  module LinkResolvable
+    attr_accessor :source
+  end
+end

data/lib/rails_connector/lucene_search_request.rb

@@ -0,0 +1,102 @@
+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)
+      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 + 1.second).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|
+        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
+      result
+    end
+  end
+end

data/lib/rails_connector/markdown_string.rb

@@ -0,0 +1,17 @@
+module RailsConnector
+  # Include this module in order to tag the string as one with Markdown content
+  module MarkdownString
+    include LinkResolvable
+    # Returns whether the String contains Markdown (default to true, overrides String.markdown?).
+    def markdown?
+      true
+    end
+  end
+end
+
+class String
+  # Returns whether the String contains Markdown (default to false).
+  def markdown?
+    false
+  end
+end

data/lib/rails_connector/meta.rb

@@ -0,0 +1,143 @@
+module RailsConnector
+  module Meta
+    # This method is an equivalent of Rails.logger.silence, which has been deprecated
+    def self.hello_im_rails_and_im_retarted_so_please_be_patient
+      old_logger_level = Rails.logger.level
+      Rails.logger.level = Logger::ERROR
+      yield self
+    ensure
+      Rails.logger.level = old_logger_level
+    end
+
+    def self.included(base) #:nodoc:
+      #  Class enhancements
+      base.extend(ClassMethods)
+    end
+
+    # The RailsConnector::ObjClass object for this file format.
+    # This will always return a proper object, even if no custom
+    # Ruby class exists.
+    def obj_class_definition
+      @obj_class_definition ||= RailsConnector::Meta::EagerLoader.instance.obj_class(obj_class)
+    end
+    alias_method :obj_class_def, :obj_class_definition
+
+    # Returns true, if there is a custom Ruby class defined for the object
+    # or false, if it is represented by RailsConnector::Obj
+    def has_custom_ruby_class?
+      self.class.is_custom_ruby_class?
+    end
+
+    # Returns the custom attributes in the form of a Hash.
+    def custom_attributes
+      obj_class_definition.custom_attributes
+    end
+
+    # Returns true, if the file format has an attribute of the given name.
+    def custom_attribute?(attr)
+      obj_class_definition.custom_attribute?(attr)
+    end
+
+    # Returns an Array of String of all mandatory attributes, no mather if it's
+    # custom or built-in. Built-in attributes are underscored (valid_from,
+    # not validFrom).
+    # Possible +options+ are:
+    # <tt>:only_custom_attributes</tt>:: Return only custom attributes, omit
+    # built-in attributes like content_type or valid_from.
+    def mandatory_attribute_names(options = {})
+      obj_class_definition.mandatory_attribute_names(options)
+    end
+
+    # Returns true, if the file format has an mandatory attribute of the given name.
+    def mandatory_attribute?(attr)
+      obj_class_definition.mandatory_attribute?(attr)
+    end
+
+    # Returns the version of this object. This number is increased every time
+    # this object is released.
+    def version
+      load_meta_details
+      @object_with_meta_data.version.presence.to_i || 0
+    end
+
+    # Returns the time of the reminder, if it is set.
+    def reminder_from
+      load_meta_details
+      @object_with_meta_data.reminder_from.presence &&
+        ::ActiveModel::Type::DateTime.new.deserialize(@object_with_meta_data.reminder_from)
+    end
+
+    # Returns the reminder comment, if a reminder is set.
+    def reminder_comment
+      load_meta_details
+      @object_with_meta_data.reminder_comment
+    end
+
+    # Return the name of the workflow, that is assigned to this object.
+    def workflow_name
+      load_meta_details
+      @object_with_meta_data.workflow_name
+    end
+
+    # Return the current editor as a String. If there is no edited content,
+    # which is always the case in live mode, an empty String is returned.
+    # The 'contents' table is queried for this information.
+    def editor
+      return @editor if @editor
+
+      load_meta_details
+
+      content_id =
+        if edited?
+          @object_with_meta_data.edited_content_id
+        else
+          @object_with_meta_data.released_cont_id
+        end
+
+      if content_id
+        content = RailsConnector::Content.find(content_id)
+        @editor = content.editor
+      else
+        @editor = ""
+      end
+    end
+
+    def committed?
+      load_meta_details
+      !@object_with_meta_data.committed_cont_id.nil?
+    end
+
+    private
+
+    # Load the objects details from the `objects' tables.
+    def load_meta_details #:nodoc:
+      return if @object_with_meta_data
+
+      @object_with_meta_data = RailsConnector::ObjectWithMetaData.find(id)
+
+      # reset depending instance variables
+      @editor = nil
+    end
+
+    # the methods in this module will become class methods
+    module ClassMethods
+      # The RailsConnector::ObjClass object for this file format.
+      # This will only return a proper object if a custom Ruby class exists
+      # and will throw a RuntimeError otherwise.
+      def obj_class_definition
+        unless is_custom_ruby_class?
+          raise "Obtaining the obj_class_definition of an Obj without custom Ruby class " \
+                    "is logically impossible."
+        end
+        @obj_class_definition ||= RailsConnector::Meta::EagerLoader.instance.obj_class(name)
+      end
+      alias_method :obj_class_def, :obj_class_definition
+
+      # RailsConnector::AbstractObj returns false, everything else true.
+      # TODO: RailsConnector::AbstractObj does not exist here
+      def is_custom_ruby_class?
+        self != RailsConnector::BasicObj
+      end
+    end
+  end
+end

data/lib/rails_connector/meta/eager_loader.rb

@@ -0,0 +1,84 @@
+require "singleton"
+require "set"
+
+module RailsConnector
+  module Meta
+    class EagerLoader
+      include Singleton
+      attr_reader :obj_classes
+
+      def initialize
+        # Rails.logger.debug "EagerLoader: I am eager to start working"
+        @obj_classes = {}
+        RailsConnector::ObjClass.includes(:custom_attributes_raw).all.each do |obj_class|
+          @obj_classes[obj_class.name] = obj_class if obj_class
+        end
+        preload_attribute_blobs
+      end
+
+      def obj_class(name)
+        name = name.to_s
+        if !@obj_classes.fetch(name, nil).nil?
+          @obj_classes[name]
+        else
+          # TODO: preload_attribute_blobs for obj_class
+          @obj_classes[name] ||= RailsConnector::ObjClass.find_by_obj_class_name(name)
+        end
+      end
+
+      def forget_obj_class(name)
+        @obj_classes.delete(name.to_s)
+      end
+
+      protected
+
+      def preload_attribute_blobs
+        attribute_names = Set.new
+        @obj_classes.each do |_, obj_class|
+          obj_class.custom_attributes.each do |attribute_name, _|
+            attribute_names << attribute_name
+          end
+        end
+
+        blob_names = attribute_names.map { |attribute_name| "#{attribute_name}.jsonAttributeDict" }
+        # Fiona >= 6.8
+        if RailsConnector::BlobMapping.exists?
+          blob_names               = attribute_names.map { |attribute_name| "#{attribute_name}.jsonAttributeDict" }
+          fingerprint_map          = RailsConnector::BlobMapping.get_fingerprint_map(blob_names)
+          blob_fingerprints        = fingerprint_map.values
+          # NOTE: this is correct!
+          blobs                    = RailsConnector::Blob.where(blob_name: blob_fingerprints).to_a
+          blob_map                 = Hash[blobs.map { |b| [b.blob_name, b] }]
+
+          @obj_classes.each do |_, obj_class|
+            obj_class.custom_attributes.each do |_, attribute|
+              blob_name   = "#{attribute.name}.jsonAttributeDict"
+              fingerprint = fingerprint_map[blob_name]
+              blob        = blob_map[fingerprint]
+
+              next unless blob&.blob_data?
+
+              attribute.instance_variable_set(:@blob_data, ::JSON.parse(blob.blob_data))
+            end
+          end
+        # Fiona = 6.7
+        else
+          blob_names               = attribute_names.map { |attribute_name| "#{attribute_name}.jsonAttributeDict" }
+          blobs                    = RailsConnector::Blob.where(blob_name: blob_names).to_a
+          blob_map                 = Hash[blobs.map { |b| [b.blob_name, b] }]
+
+          @obj_classes.each do |_, obj_class|
+            obj_class.custom_attributes.each do |_, attribute|
+              blob_name   = "#{attribute.name}.jsonAttributeDict"
+              blob        = blob_map[blob_name]
+
+              next unless blob&.blob_data?
+
+              attribute.instance_variable_set(:@blob_data, ::JSON.parse(blob.blob_data))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_connector/named_link.rb

@@ -0,0 +1,90 @@
+module RailsConnector
+  # This class provides methods used to retrieve objects from CMS based an entry
+  # in CMS of the obj_class <tt>NamedLink</tt>.
+  # @api public
+  class NamedLink
+    LINKLIST_NAME = "related_links".freeze
+
+    # @api public
+    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
+
+      # add method for get related_links attiribute for simply Obj-instance
+      attributes = RailsConnector::Attribute.where(attribute_name: LINKLIST_NAME)
+      if attributes.length != 0
+        Obj.send(:define_attribute, LINKLIST_NAME, ActiveRecord::Type::String.new)
+        Obj.send(:delegate, LINKLIST_NAME.to_sym, to: :attr_dict)
+      else
+        Rails.logger.warn "Check if you NamedLink class is defined properly. Attibute related_links does not exist."
+        # there is not attribute named 'related_links' defined
+        @@named_links_cache = []
+        @@updated_at = Time.now
+        return nil
+      end
+
+      found_objects = BasicObj.where(obj_class: "NamedLink")
+      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
+                            .flat_map(&:related_links)
+                            .each_with_object({}) do |link_obj, temp|
+        temp[link_obj.title] = link_obj.destination_object
+      end
+
+      @@updated_at = Time.now
+      nil
+    end
+
+    # Sets the time in minutes after which the cache will be expired.
+    # The default expiry time is set to 1 minute
+    # @api public
+    def self.cache_expiry_time=(value)
+      @@cache_expiry_time = value
+    end
+
+    def self.cache_expiry_time
+      @@cache_expiry_time || 1
+    end
+
+    def self.cache_expired?
+      @@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.
+    # @api public
+    def self.get_object(title, options = {})
+      object = named_links[title.to_s]
+      raise NotFound, "The NamedLink '#{title}' does not exist" if object.nil?
+
+      options[:cache] == false ? object.reload : object
+    end
+
+    def self.reset_cache
+      @@named_links_cache = nil
+    end
+
+    def self.named_links
+      reset_cache if cache_expired?
+      generate_named_links_cache unless named_links_cache
+      named_links_cache
+    end
+
+    def self.named_links_cache
+      @@named_links_cache
+    end
+  end
+end