infopark_fiona7 0.71.1.12 → 1.1.0.0.0

data/lib/fiona7/scrivito_patches/link_parser.rb

@@ -2,21 +2,14 @@ require 'scrivito/link_parser'
 
 module Scrivito
   class LinkParser
-    alias_method :original_parse, :parse
-
-    # Patch parse to handle numerical ids
-    def parse(url)
-      url = url.to_s if url
-      original_parse(url)
-    end
-
     # Patch to handle legacy mode
-    def application_route?(uri)
-      route_params = route(uri)
-      route_params && (
-        route_params[:controller] == 'scrivito/cms_dispatch' ||
-        route_params[:controller] == 'rails_connector/cms_dispatch'
+    def dispatch_route_for(route_params)
+      if route_params && (
+        (route_params[:controller] == 'scrivito/cms_dispatch') ||
+        (route_params[:controller] == 'rails_connector/cms_dispatch')
       )
+        route_params
+      end
     end
   end
 end

data/lib/fiona7/scrivito_patches/log_subscriber.rb

@@ -0,0 +1,18 @@
+module Scrivito
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def backend_request(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      duration = '(%.1fms)' % [event.duration]
+
+      param = event.payload[:params]
+      param_text = " #{param}" if param
+
+      verb_text = event.payload[:verb].upcase
+      path_text = event.payload[:path]
+
+      debug "  Fiona7 #{verb_text} #{path_text}#{param_text} #{duration}"
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/preset_routes.rb

@@ -0,0 +1,47 @@
+module Scrivito
+  module PresetRoutes
+    def self.install_into(route_set)
+      return if Scrivito::Configuration.scrivito_route_enabled?
+
+      Scrivito::Configuration.with_scrivito_route_enabled do
+        route_set.draw do
+          scrivito_route '/', using: "homepage", via: :all
+
+          if Scrivito::Configuration.legacy_routing
+            scrivito_route ':id(/*slug)', using: "slug_id", via: :all
+          else
+            scrivito_route '(/)(*slug-):id', using: "slug_id", via: :all
+
+            match ':id(/*slug)', to: 'scrivito/legacy_redirect#index', via: :all, constraints: {
+              id: /[0-9]{4,}/
+            }
+          end
+
+          scrivito_route '/*permalink', using: "permalink", format: false, via: :all
+        end
+      end
+    end
+
+    def self.install_slave_into(route_set)
+      return if Scrivito::Configuration.scrivito_route_enabled?
+
+      Scrivito::Configuration.with_scrivito_route_enabled do
+        route_set.draw do
+          scrivito_route '/f7(/)', using: "homepage", via: :all
+
+          if Scrivito::Configuration.legacy_routing
+            scrivito_route '/f7/:id(/*slug)', using: "slug_id", via: :all
+          else
+            scrivito_route '/f7/(*slug-):id', using: "slug_id", via: :all
+
+            match '/f7/:id(/*slug)', to: 'scrivito/legacy_redirect#index', via: :all, constraints: {
+              id: /[0-9]{4,}/
+            }
+          end
+
+          scrivito_route '/f7/*permalink', using: "permalink", format: false, via: :all
+        end
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/routing_extensions.rb

@@ -0,0 +1,48 @@
+module Scrivito
+
+module RoutingExtensions
+
+  def scrivito_route(path, using:, format: nil, via: :get)
+    assert_scrivito_route_enabled
+    # @set is a ActionDispatch::Routing::RouteSet
+    # see: http://git.io/v4UYF and http://git.io/v4UOI
+    route_set = @set
+
+    route_name = using.to_sym
+
+    route = Route.register(route_set, route_name)
+
+    options = {
+      to: 'scrivito/cms_dispatch#index',
+      via: via,
+      format: format,
+      as: route.helper_name,
+    }
+
+    # removed fixed length constraint on ids
+    options[:constraints] = {id: /[0-9]{4,}/} if route_name == :slug_id
+
+    begin
+      match(path, options)
+    rescue ArgumentError => error
+      if error.message.include?(route.helper_name)
+        raise ScrivitoError,
+            %(You have already defined a Scrivito route with the name "#{route_name}".)
+      else
+        raise error
+      end
+    end
+  end
+
+  private
+
+  def assert_scrivito_route_enabled
+    unless Scrivito::Configuration.scrivito_route_enabled?
+      raise ScrivitoError, 'The preset routes are still enabled. Please disable them by ' \
+        'setting the configuration "inject_preset_routes" to false before using scrivito_route'
+    end
+  end
+
+end
+
+end

data/lib/fiona7/search_engine.rb

@@ -16,5 +16,9 @@ module Fiona7
     def results
       raise "Not implemented"
     end
+
+    def objects
+      raise "Not implemented"
+    end
   end
 end

data/lib/fiona7/type_loader.rb

@@ -1,3 +1,6 @@
+require "fiona7/obj_class_name_mangler"
+require "fiona7/obj_class_name_demangler"
+
 module Fiona7
   class TypeLoader
     class AttributeTypeHelper
@@ -20,8 +23,7 @@ module Fiona7
 
     def initialize(obj_class)
       self.obj_class    = obj_class
-      self.name_aliaser = TypeRegister::NameAliaser.new(virtual: obj_class)
-      self.rc_obj_class = RailsConnector::Meta::EagerLoader.instance.obj_class(self.name_aliaser.real_obj_class)
+      self.rc_obj_class = RailsConnector::Meta::EagerLoader.instance.obj_class(Fiona7::ObjClassNameMangler.new(self.obj_class).mangle)
 
     end
 
@@ -43,7 +45,7 @@ module Fiona7
       self.rc_obj_class.custom_attributes.each do |real_name, cms_attribute|
         next if Fiona7::Initializer::ATTRIBUTES_MAP.key?(real_name)
 
-        # TODO: move this to a better place
+        # TODO: move this to a better place ~> AttributeNameDemangler
         if Fiona7.mode == :standalone
           virtual_name = real_name.sub("s_#{self.rc_obj_class.name}__", "")
         else
@@ -60,7 +62,6 @@ module Fiona7
     end
 
     protected
-    attr_accessor :name_aliaser
     attr_writer :obj_class, :rc_obj_class
 
   end

data/lib/fiona7/type_register.rb

@@ -2,6 +2,10 @@ require 'set'
 require 'singleton'
 require 'fiona7/type_loader'
 require 'fiona7/type_synchronizer'
+require "fiona7/obj_class_name_mangler"
+require "fiona7/obj_class_name_demangler"
+require "fiona7/attribute_name_mangler"
+
 
 module Fiona7
   class TypeRegister
@@ -16,21 +20,6 @@ module Fiona7
       stringlist:     :text
     }.freeze
 
-    class NameAliaser
-      attr_accessor :virtual_obj_class, :real_obj_class
-
-      def initialize(input={})
-        if input[:virtual]
-          self.virtual_obj_class = input[:virtual]
-          self.real_obj_class = input[:virtual].gsub('::', '__')
-        elsif input[:real]
-          self.real_obj_class = input[:real]
-          self.virtual_obj_class = input[:real].gsub('__','::')
-        else
-          raise "Invalid input for NameAliaser"
-        end
-      end
-    end
     class TypeDefinition
       class Attribute < Struct.new(:name, :type, :real_name, :real_type, :values)
         class Core < Struct.new(:name, :type)
@@ -49,31 +38,24 @@ module Fiona7
       end
 
       attr_accessor :name
+      attr_accessor :real_name
       attr_accessor :attrs
       attr_accessor :aliaser
 
       def initialize(name)
         self.name = name
+        self.real_name = Fiona7::ObjClassNameMangler.new(name).mangle
         self.attrs = Set.new
-        self.aliaser = NameAliaser.new(virtual: name)
       end
 
-      def real_name
-        self.aliaser.real_obj_class
-      end
 
       def virtual_name
-        self.aliaser.virtual_obj_class
+        self.name
       end
 
       def add_attr(name, type, real_name=nil, real_type=nil, values=nil)
         real_type ||= TYPE_MAP[type.to_sym] || type
-        # TODO: move this to a better place
-        if Fiona7.mode == :standalone
-          real_name ||= "s_#{self.real_name}__#{name}"
-        else
-          real_name ||= name
-        end
+        real_name = Fiona7::AttributeNameMangler.new(name, self.name).mangle
         self.attrs << Attribute.new(name.to_s, type.to_sym, real_name.to_s, real_type.to_sym, values)
       end
 
@@ -125,6 +107,10 @@ module Fiona7
       self.cms_def_present?(obj_class)
     end
 
+    def read_all
+      self.cms_defs.values
+    end
+
     def write?(obj_class)
       true &&
         self.usr_def_present?(obj_class) &&
@@ -133,7 +119,7 @@ module Fiona7
     end
 
     def read_mangled(obj_class)
-     read(NameAliaser.new(real: obj_class).virtual_obj_class)
+      read(Fiona7::ObjClassNameDemangler.new(obj_class).demangle)
     end
 
     def read(obj_class)

data/lib/fiona7/type_synchronizer.rb

@@ -1,31 +1,33 @@
 require 'fiona7/builder/obj_class_builder'
 require 'fiona7/builder/obj_class_updater'
+require 'fiona7/obj_class_name_mangler'
 
 module Fiona7
   class TypeSynchronizer
-    attr_reader :type_definition, :name_aliaser
+    attr_reader :type_definition
 
     def initialize(type_definition)
       self.type_definition = type_definition
-      self.name_aliaser    = TypeRegister::NameAliaser.new(virtual: type_definition.name)
+      self.real_obj_class  = Fiona7::ObjClassNameMangler.new(type_definition.name).mangle
     end
 
     def synchronize
       return if skip_this_class?
 
       Reactor::Sudo.su(Fiona7.root) do
-        if RailsConnector::ObjClass.exists?(:obj_class_name => self.name_aliaser.real_obj_class)
+        if RailsConnector::ObjClass.exists?(:obj_class_name => self.real_obj_class)
           Fiona7::Builder::ObjClassUpdater.new(self.builder_values).build
         else
           Fiona7::Builder::ObjClassBuilder.new(self.builder_values).build
         end
 
-        RailsConnector::Meta::EagerLoader.instance.forget_obj_class(self.name_aliaser.real_obj_class)
+        RailsConnector::Meta::EagerLoader.instance.forget_obj_class(self.real_obj_class)
       end
     end
 
     protected
-    attr_writer :type_definition, :name_aliaser
+    attr_writer :type_definition
+    attr_accessor :real_obj_class
 
     def skip_this_class?
       case self.type_definition.name
@@ -38,7 +40,7 @@ module Fiona7
 
     def builder_values
       {
-        name: self.name_aliaser.real_obj_class,
+        name: self.real_obj_class,
         attributes: self.builder_attributes
       }
     end

data/lib/fiona7/verity_search_engine.rb

@@ -2,18 +2,29 @@ require "fiona7/search_engine"
 require "rails_connector/verity_search_request"
 require "fiona7/custom_verity_accessor"
 
+require "fiona7/attribute_names_from_queries"
+require "fiona7/attribute_names_from_cms"
+
 module Fiona7
   class VeritySearchEngine < SearchEngine
-    def results
+    def initialize(*args)
+      super
       # scrivito sdk likes to send a query with limit 0
       # just to fetch the total count of results
       # but verity does not like limit 0 very much
       if @limit == 0
         @limit = 1
       end
+    end
+
+    def results
+      @results || fetch_results
+    end
+
+    def objects
+      return @objects if @objects
 
-      construct_search_request
-      fetch_results
+      @results || fetch_results
       fetch_objects
     end
 
@@ -24,12 +35,14 @@ module Fiona7
       options[:sort_order] = [["score", "desc"], ["lastChanged", "desc"]]
       options[:limit] = @limit.to_i if @limit
       options[:offset] = @offset.to_i if @offset.to_i > 0
-      @search_request = VeritySearchRequest.new(@query, options, @klass == Fiona7::ReleasedObj)
+      VeritySearchRequest.new(@query, options, @klass == Fiona7::ReleasedObj)
     end
 
     def fetch_results
-      @results = @search_request.fetch_hits
-      @count = @results.total_hits
+      @search_request = construct_search_request
+      @search_response = @search_request.fetch_hits
+      @count = @search_response.total_hits
+      @results = @search_response.map(&:id)
     end
 
     def fetch_objects
@@ -39,7 +52,9 @@ module Fiona7
 
     class VeritySearchRequest < ::RailsConnector::VeritySearchRequest
       def initialize(query, options={}, use_released=false)
+        @query = query
         @query_string = build_query_string(query)
+        puts "VERITY QUERY:\n#{@query_string}"
         @options = default_search_options.merge(options)
         @use_released ||= use_released
       end
@@ -69,39 +84,44 @@ module Fiona7
 
       def complex_query_string(query)
         conditions = query.map do |q|
-          unresolved_field = q[:field]
-          resolved_field = resolve_field_name(unresolved_field)
+          field = resolve_field_name(q[:field])
 
-          # paths are sadly not in the search index.
-          next if resolved_field == :visiblePath
+          # paths are sadly not in the search index by default.
+          next if field == :visiblePath
 
           case q[:operator]
           when :equal
-            if unresolved_field == :_modification
+            if field == :__dummy__
               '("edited" <#IN> state)'
             else
-              field_operator_value(resolved_field, "=", q[:value])
+              search_in(field, q[:value])
             end
           when :search
-            if unresolved_field == :'*'
+            if field == :'*'
               full_text_query_string(as_values_array(q[:value]))
             else
-              field_operator_value(resolved_field, "<#CONTAINS>", q[:value])
+              values = as_values_array(q[:value])
+              values = values.map {|v| "*#{v}*" }
+              search_in(field, values)
             end
           when :greater_than
-            field_operator_value(resolved_field, ">", q[:value])
+            search_term(field, ">", q[:value])
           when :less_than
-            field_operator_value(resolved_field, "<", q[:value])
+            search_term(field, "<", q[:value])
           when :prefix, :prefix_search
-            if unresolved_field == :'*'
+            if field == :'*'
               values = as_values_array(q[:value])
               values = values.map {|v| "#{v}*" }
               full_text_query_string(values)
             else
               values = as_values_array(q[:value])
               values = values.map {|v| "#{v}*" }
-              values_operator_field(values, "<#IN>", resolved_field)
+              search_in(field, values)
             end
+          when :__in__
+            search_in(field, q[:value])
+          when :__not_in__
+            search_not_in(field, q[:value])
           else
             raise "Operator: #{q[:operator]} not supported"
           end
@@ -114,31 +134,40 @@ module Fiona7
         end
       end
 
-      def field_operator_value(field, operator, values)
+      def search_in(field, values)
         values = [values] unless values.kind_of?(Array)
+        if [:objClass, :obj_id, :permalink, :lastChanged, :name].include?(field)
+          fields = [field.to_s]
+        else
+          fields = Fiona7::AttributeNamesFromQueries.new(field.to_s, @query).attributes || Fiona7::AttributeNamesFromCms.new(field.to_s).attributes || [field.to_s]
+        end
 
-        condition = values.map do |value|
-          %|(#{field} #{operator} "#{self.class.sanitize(value)}")|
-        end.join(", ")
+        sanitized_values = values.map {|v| "`#{self.class.sanitize(v)}`" }
+        %|(<#OR> ((#{sanitized_values.join(', ')}) <#IN> (#{fields.join(', ')})))|
+      end
 
-        %|(<#OR> #{condition})|
+      def search_not_in(field, values)
+        %|(<#NOT> (#{search_in(field, values)}))|
       end
 
-      def values_operator_field(values, operator, field)
+      def search_term(field, operator, values, options={})
         values = [values] unless values.kind_of?(Array)
+        join_op = options[:join] || "OR"
+        negate  = options[:negate] ? "<#NOT> " : ""
+        reverse = options[:reverse]
 
         condition = values.map do |value|
-          %|("#{self.class.sanitize(value)}" #{operator} #{field})|
+          if reverse
+            %|(#{negate}`#{self.class.sanitize(value)}` #{operator} #{field})|
+          else
+            %|(#{negate}#{field} #{operator} `#{self.class.sanitize(value)}`)|
+          end
         end.join(", ")
 
-        %|(<#OR> #{condition})|
+        %|(<##{join_op}> #{condition})|
       end
 
       def resolve_field_name(field)
-        if Fiona7.mode != :legacy
-          Rails.logger.error("This method is not compatible with modes other than legacy")
-        end
-
         case field
         when :_obj_class
           :objClass
@@ -212,6 +241,24 @@ module Fiona7
         conditions[:notWidget] = '(objClass <#ENDS/NOT> "Widget")'
         conditions
       end
+
+    def find_obj_class_in_query(query)
+      obj_class_q = query.find {|q| q[:operator] == :equal && q[:field] == :_obj_class && !q[:value].kind_of?(Array) }
+      obj_class_q[:value] if obj_class_q
+    end
+
+    def real_field_name_in_obj_class(obj_class, field)
+      type_def = Fiona7::TypeRegister.instance.read(obj_class)
+      if type_def
+        attribute = type_def.find_attribute(field)
+        if attribute
+          field = attribute.real_name
+        end
+      end
+
+      field
+    end
     end
+
   end
 end