infopark_fiona7 1.2.0.0.1 → 1.2.0.1.1

data/lib/fiona7/controllers/rest_api/obj_controller.rb

@@ -15,6 +15,9 @@ require 'fiona7/assert'
 require 'fiona7/json/reverse_obj_decorator'
 require 'fiona7/json/typeless_obj_decorator'
 
+require 'fiona7/prefetch/obj_prefetch'
+require 'fiona7/prefetch/widget_resolver_prefetch'
+
 module Fiona7
   module Controllers
     module RestAPI
@@ -61,10 +64,13 @@ module Fiona7
           # FIXME: code duplication with fetch_by_id
           obj_ids = payload.with_indifferent_access[:ids]
           klass = revision_id.start_with?('f') ? ReleasedObj : EditedObj
-          objs = klass.where(obj_id: obj_ids)
-          objs_arr = obj_ids.map {|obj_id| objs.find {|o| o.id == obj_id.to_i } }
 
-          decorated = objs_arr.map {|obj| obj ? Fiona7::JSON::ReverseObjDecorator.new(klass, obj) : nil }
+          # preloads all objects in one query
+          objs_arr = Prefetch::ObjPrefetch.new(klass, obj_ids).find_many(obj_ids)
+          # preloads all widgets in one query
+          widget_prefetch = Prefetch::WidgetResolverPrefetch.new(klass, objs_arr.compact)
+
+          decorated = objs_arr.map {|obj| obj ? Fiona7::JSON::ReverseObjDecorator.new(klass, obj, widget_prefetch.widget_resolver(obj)) : nil }
           response = ::JSON.parse(::ActiveSupport::JSON.encode({"results" => decorated}))
           return response
         end
@@ -112,11 +118,23 @@ module Fiona7
             conti = {}
           end
 
+          # This simulates the behavior of the backend:
+          # In absence of other input backend always sorts by ID
+          # or SCORE if an elastic search for such request would
+          # produce a score.
+          if (params[:query]||[]).any?{|op| (op[:operator]||op["operator"]).to_s =~ /search/ }
+            default_sort_order = :desc
+            default_sort_by = :_score
+          else
+            default_sort_order = :asc
+            default_sort_by = :id
+          end
+
           offset = conti[:offset]      || params[:offset]     || 0
           # 10 is the default value in original implementation
           size   = conti[:size]        || params[:size]       || 10
-          order  = (conti[:sort_order] || params[:sort_order] || :asc).to_sym
-          sort   = (conti[:sort_by]    || params[:sort_by]    || :id).to_sym
+          order  = (conti[:sort_order] || params[:sort_order] || default_sort_order).to_sym
+          sort   = (conti[:sort_by]    || params[:sort_by]    || default_sort_by).to_sym
 
           if params[:query].present?
             normalize_query_params(params[:query])

data/lib/fiona7/engine.rb

@@ -59,6 +59,9 @@ require 'fiona7/type_synchronizer'
 require 'fiona7/naive_search_engine'
 require 'fiona7/verity_search_engine'
 
+# tools
+require 'fiona7/tools/attribute_remover'
+
 module Fiona7
   mattr_accessor :mode
   mattr_accessor :login
@@ -71,6 +74,42 @@ module Fiona7
     :release_obj => []
   }
 
+  # Allows to specify custom typing for virtual attribute types
+  # Besides the built in mapping:
+  #    link:           :linklist,
+  #    reference:      :linklist,
+  #    referencelist:  :linklist,
+  #    widgetlist:     :linklist,
+  #    binary:         :linklist,
+  #    number:         :string,
+  #    stringlist:     :text
+  #
+  # Following other options are supported:
+  #    reference:      :string,
+  #    referencelist:  :text
+  #
+  # Custom mappings can be specified per obj_class:
+  #
+  #   custom_attribute_types = {
+  #     'MyPage' => {
+  #       child_order: :text
+  #     }
+  #   }
+  # 
+  # or per attribute:
+  #
+  #   custom_attribute_types = {
+  #     child_order: :text
+  #   }
+  #
+  # or using a callable entity like a proc:
+  #
+  #   custom_attribute_types = lambda do |obj_class, attribute|
+  #     :text if attribute == :child_order
+  #   end
+  mattr_accessor :custom_attribute_types
+  self.custom_attribute_types = {}
+
   mattr_accessor :search_engine
   self.search_engine = Fiona7::VeritySearchEngine
 

data/lib/fiona7/json/obj_decorator.rb

@@ -6,10 +6,11 @@ module Fiona7
 end
 
 require 'fiona7/assert'
-require 'fiona7/link_converter/fiona_to_scrivito'
 require 'fiona7/json/widget_decorator'
 require 'fiona7/widget_resolver'
-require 'fiona7/blob_id_generator'
+require 'fiona7/prefetch/obj_prefetch'
+
+require 'fiona7/attribute_readers/factory'
 
 module Fiona7
   module JSON
@@ -18,12 +19,10 @@ module Fiona7
         @klass = klass
         @obj = obj
 
-        @link_converter = LinkConverter::FionaToScrivito.new(obj)
-
         if widget_resolver
           @widget_resolver = widget_resolver
         elsif (widget_links = @obj.attr_values["X_widget_pool"])
-          @widget_resolver = WidgetResolver.new(widget_links, @klass)
+          @widget_resolver = WidgetResolver.new(widget_links, Prefetch::ObjPrefetch.new(klass))
         end
       end
 
@@ -58,137 +57,46 @@ module Fiona7
 
       def add_custom_attributes(attrs, *args)
         type_definition = Fiona7::TypeRegister.instance.read_mangled(@obj.obj_class)
+        factory = Fiona7::AttributeReaders::Factory.new(@obj, type_definition, @widget_resolver)
+
         type_definition.attrs.each do |attribute|
           virtual_attribute_name = attribute.name
           real_attribute_name    = attribute.real_name
           virtual_attribute_type = attribute.type.to_sym
-
-          val = case virtual_attribute_type
-          when :link
-            deserialize_link(@obj.attr_values[real_attribute_name].try(:first))
-          when :linklist
-            (@obj.attr_values[real_attribute_name] || []).map {|link| deserialize_link(link) }
-          when :multienum
-            @obj[real_attribute_name] || []
-          when :reference
-            deserialize_reference(@obj.attr_values[real_attribute_name].try(:first))
-          when :referencelist
-            (@obj.attr_values[real_attribute_name] || []).map {|link| deserialize_reference(link) }.compact
-          when :date
-            if real_attribute_name == "valid_from" || real_attribute_name == "valid_until"
-              # a bug in fiona connector -> [valid_(from|until)] returns a raw string
-              @obj[real_attribute_name]
-            else
-              @obj[real_attribute_name].try(:utc).try(:to_iso)
-            end
-          when :widgetlist
-            deserialize_widget_field(@obj.attr_values[real_attribute_name] || [])
-          when :html
-            deserialize_html(@obj[real_attribute_name])
-          when :markdown
-            nil
-          when :binary
-            if !Fiona7.mode == :legacy || !@obj.binary?
-              deserialize_binary(@obj.attr_values[real_attribute_name].try(:first))
-            else
-              {id: Fiona7::BlobIdGenerator.new(@obj.id, @obj.last_changed).call}
-            end
-          when :enum, :multienum, :text, :string
-            if real_attribute_name == "suppress_export"
-              @obj[real_attribute_name].to_s
-            else
-              @obj[real_attribute_name]
-            end
-          when :number
-            @obj[real_attribute_name].to_f
-          when :stringlist
-            if Fiona7.mode == :legacy && real_attribute_name == "channels"
-              @obj["channels"] || []
-            else
-              # TODO: get rid of this rescue nil
-              ::JSON.parse(@obj[real_attribute_name]) rescue nil 
-            end
+          # This is probably the most important line in this whole class.
+          # An intuitive way of reading the real attribute type
+          # would be to just look-up in the attribute definition.
+          #
+          # But this approach is wrong. Consider the following case:
+          # An attribute :child_order is created with real type :linklist
+          # This proves problematic (because of the unwanted links in CMS)
+          # and is later changed to :text. But the CMS still contains
+          # "old" objects with :child_order modelled as :linklist.
+          # Therefore we must lookup the correct typing in the attribute itself.
+          #
+          # It is also possible that the obj does not have any content for the
+          # attribute. In this case we just use the type provided by 
+          # the type definition.
+          real_attribute_type = ((@obj.attr_dict.send(:attr_defs) || {})[real_attribute_name.to_s]||{})["type"] ||
+            attribute.real_type
+
+          worker = factory.call(real_attribute_name, virtual_attribute_type, real_attribute_type)
+          if worker.nil?
+            Rails.logger.error("Unable to deserialize #{virtual_attribute_name} in #{type_definition.name}")
+            val = nil
           else
-            Assert.success(
-              false,
-              "Unknown attribute type #{virtual_attribute_type} for attribute: #{virtual_attribute_name}"
-            )
+            val = worker.call
           end
 
           # TODO: better handling for attribute types
           if virtual_attribute_type  == :text
             virtual_attribute_type = :string
           end
-          attrs[virtual_attribute_name] = [val, virtual_attribute_type]
-        end
-      end
 
-      def deserialize_link(link)
-        if link
-          deserialized = {
-            # remove possible external prefix for protcol-less urls
-            url: link["url"].try(:gsub, /\Aexternal:/, ''),
-            title: link["title"],
-            target: link["target"],
-            # content service uses destination
-            destination: link["destination"].to_s,
-            # rest api uses obj_id
-            obj_id: link["destination"].to_s,
-            query: link["search"],
-            fragment: link["fragment"]
-          }
-
-          # TODO: refactor this code
-          if deserialized[:url].present?
-            deserialized.delete(:destination)
-            deserialized.delete(:obj_id)
-          end
-
-          deserialized
-        end
-      end
-
-      def deserialize_reference(link)
-        if link && link["type"] == "internal"
-          link["destination"].to_s
-        end
-      end
-
-      def deserialize_widget_field(linklist)
-        if !linklist.empty?
-          widget_ids = []
-          widgets = linklist.map do |link|
-            widget_id = link["title"]
-            # sometimes a released page references an unreleased widget
-            # it is then impossible to load it into widget_pool
-            # but the reference in the widgetlist field is still there
-            # therefore we need to check if the widget has been loaded
-            # into the pool - only then it can be included
-            if valid_widget_id?(widget_id)
-              widget_ids << widget_id
-            end
-          end
-
-          widget_ids
-        end
-      end
-
-      def deserialize_html(html)
-        @link_converter.convert(html)
-      end
-
-      def deserialize_binary(link)
-        if link
-          binary_id = link["title"]
-          if binary_id.length == 32 && binary_id =~ /0{16,}0*[0-9]+/
-            {id: binary_id}
-          end
+          attrs[virtual_attribute_name] = [val, virtual_attribute_type]
         end
       end
 
-      def valid_widget_id?(widget_id)
-        @widget_resolver && @widget_resolver.path_map[widget_id]
-      end
 
       def replace_widget_pool(attrs, *args)
         if (widget_links = @obj.attr_values["X_widget_pool"]) && @widget_resolver

data/lib/fiona7/prefetch/obj_prefetch.rb

@@ -0,0 +1,42 @@
+require 'set'
+
+module Fiona7
+  module Prefetch
+    class ObjPrefetch
+      def initialize(klass, prefetch_ids=[])
+        self.klass          = klass
+        self.prefetched_ids = Set.new
+        self.object_id_map  = {}
+
+        self.prefetch_objects(prefetch_ids)
+      end
+
+      # Returns an object with given ID or nil if no matching object found
+      def find_one(id)
+        self.find_many([id]).first
+      end
+
+      # Returns an array with objects for given IDs.
+      # The array is ordered according to the IDs given.
+      # For missing objects the array is filled with nil values
+      def find_many(ids)
+        self.prefetch_objects(ids)
+        ids.map { |id| self.object_id_map[id.to_i] }
+      end
+
+      protected
+      attr_accessor :klass, :prefetched_ids, :object_id_map
+
+      def prefetch_objects(prefetch_ids)
+        missing = prefetch_ids.select {|id| !self.prefetched_ids.include?(id) }
+
+        return if missing.empty?
+
+        self.klass.where(obj_id: missing).each do |obj|
+          self.prefetched_ids << obj.id
+          self.object_id_map[obj.id] = obj
+        end
+      end
+    end
+  end
+end

data/lib/fiona7/prefetch/widget_resolver_prefetch.rb

@@ -0,0 +1,36 @@
+require 'fiona7/prefetch/obj_prefetch'
+require 'fiona7/widget_resolver'
+
+module Fiona7
+  module Prefetch
+    class WidgetResolverPrefetch
+      def initialize(klass, objects=[])
+        widget_object_ids = self.collect_widget_object_ids(objects)
+
+        self.obj_prefetch = ObjPrefetch.new(klass, widget_object_ids)
+      end
+
+      # Returns a widget resolver for given object.
+      # If the object is already known to the prefetcher,
+      # then widgets will be loaded from memory,
+      # instead of database.
+      def widget_resolver(object)
+        WidgetResolver.new(
+          object.attr_values["X_widget_pool"]||[],
+          self.obj_prefetch
+        )
+      end
+
+      protected
+      attr_accessor :obj_prefetch
+
+      def collect_widget_object_ids(objects)
+        objects.map do |object|
+          (object.attr_values["X_widget_pool"]||[]).map do |widget_hash|
+            widget_hash["destination"].try(:to_i)
+          end
+        end.flatten.compact
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/date_attribute.rb

@@ -0,0 +1,16 @@
+require 'scrivito/date_attribute'
+
+module Scrivito
+  module DateAttribute
+    def self.deserialize_from_backend(iso_date_time)
+      return nil unless iso_date_time
+      #return nil if iso_date.to_s.blank?
+
+      if iso_date_time.to_s =~ /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/
+        Time.utc($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i).in_time_zone
+      else
+        raise "The value is not a valid ISO date time: #{iso_date_time.inspect}"
+      end
+    end
+  end
+end

data/lib/fiona7/tools/attribute_remover.rb

@@ -0,0 +1,70 @@
+require 'fiona7/obj_class_name_mangler'
+require 'fiona7/attribute_name_mangler'
+
+module Fiona7
+  module Tools
+    # This class is used to remove attributes from obj classes.
+    # Normally it is not required, because the user can just
+    # remove an attribute from the model definition and the
+    # attribute becomes invisible.
+    # The attribute still persists, but becomes inaccessible.
+    #
+    # In some cases it may be required to garbage collect
+    # the removed attribute, for example to change the type
+    # of an attribute, the attribute has to be removed first.
+    #
+    # This class behaves differently for different configrations.
+    # In standalone mode the attribute is removed from
+    # the specified obj class and also from CMS.
+    # In legacy mode the attribute is removed from
+    # the specified obj class. If there are no more obj classes
+    # referencing this attribute, it also gets deleted from CMS.
+    class AttributeRemover
+      def initialize(obj_class, attr_name)
+        self.obj_class = ObjClassNameMangler.new(obj_class).mangle
+        self.attr_name = AttributeNameMangler.new(attr_name, obj_class).mangle
+
+        self.original_attr_name = attr_name
+        self.original_obj_class = obj_class
+      end
+
+      def remove
+        if rc_attr = RailsConnector::Attribute.find_by_attribute_name(self.attr_name)
+          # fetch the names of all obj classes referencing this attribute
+          obj_classes = rc_attr.obj_class_defs.map(&:name)
+          if obj_classes.include?(self.obj_class)
+            cm_obj_class = Reactor::Cm::ObjClass.get(self.obj_class)
+            # this removes the attribute from the obj class
+            cm_obj_class.attributes = (cm_obj_class.attributes - [self.attr_name])
+            # flush reactor cache
+            RailsConnector::Meta::EagerLoader.instance.forget_obj_class(self.obj_class)
+            # flush type register caches
+            Fiona7::TypeRegister.instance.send(:load, self.original_obj_class)
+            if typedef = Fiona7::TypeRegister.instance.usr_defs[self.original_obj_class]
+              # There is a very subtle bug hidden here:
+              # If you have an enum or multienum attribute, remove it and
+              # trigger synchronize (via write request) it will be created
+              # as string or text.
+              #
+              # Easiest way to prevent this bug is to restart the app
+              # between the requests.
+              typedef.remove_attribute(self.original_attr_name)
+            end
+            # one reference less!
+            obj_classes.delete(self.obj_class)
+          end
+
+          # NOTE: this will always be true in standlone mode
+          if obj_classes.empty?
+            # attribute can be garbage collected
+            cm_attr = Reactor::Cm::Attribute.get(self.attr_name)
+            cm_attr.delete!
+          end
+        end
+      end
+
+      protected
+      attr_accessor :obj_class, :attr_name, :original_obj_class, :original_attr_name
+    end
+  end
+end