infopark_fiona7 0.30.0.1

data/lib/fiona7/scrivito_patches/client_config.rb

@@ -0,0 +1,19 @@
+require 'scrivito/client_config'
+
+module Scrivito
+  class ClientConfig
+    alias_method :original_obj_config, :obj_config
+
+    alias_method :original_user_permissions_config, :user_permissions_config
+
+    def user_permissions_config
+      original_user_permissions_config.tap do |config|
+        # TODO: optimize this find away
+        if obj && obj.id
+          config[:write_obj] = Fiona7::WriteObj.find(obj.id).permission.write?
+        end
+      end
+    end
+
+  end
+end

data/lib/fiona7/scrivito_patches/cms_dispatch_controller.rb

@@ -0,0 +1,31 @@
+require 'scrivito/cms_dispatch_controller'
+module Scrivito
+
+  class CmsDispatchController 
+    def target_controller(env)
+      return default_controller if obj_not_found?
+      controller = "#{loaded_obj.controller_name}Controller".constantize
+
+      if controller.respond_to?(:use_for_obj_dispatch?) && controller.use_for_obj_dispatch? && controller.include?(Scrivito::ControllerActions)
+        controller
+      else
+        default_controller
+      end
+    rescue NameError
+      default_controller
+    end
+
+    def default_controller
+      return Fiona7::DefaultScrivitoCmsController if Fiona7.mode == :legacy
+      CmsController
+    rescue NameError => e
+      if e.message.include?('CmsController')
+        raise 'Your application does not define the "CmsController" needed for Scrivito. '\
+          'Did you forget to run "rails generate scrivito:install"?'
+      else
+        raise
+      end
+    end
+  end
+
+end

data/lib/fiona7/scrivito_patches/cms_rest_api.rb

@@ -0,0 +1,11 @@
+require 'scrivito/cms_rest_api.rb'
+
+module Scrivito
+  class CmsRestApi
+    # Stub upload_file since the uploads are handled directly in ruby.
+    def self.upload_file(file)
+      # file is good enough. :-)
+      file
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/cms_routing.rb

@@ -0,0 +1,66 @@
+require 'scrivito/cms_routing'
+
+module Scrivito
+  class CmsRouting
+    # patch link converter to understand numerical IDs
+    def convert_links(html)
+      if html
+        html.gsub(%r{<?\bobjid:([1-9][0-9]{3,})\b>?}) do
+          if obj = Obj.find_by_id($1)
+            path_or_url(obj, "path")
+          else
+            "#__target_object_not_reachable"
+          end
+        end
+      end
+    end
+
+    # patch router to output proper binary urls fo uploaded files
+    def path_or_url_without_editing_context(target, path_or_url, options)
+      if target.is_a?(Link)
+        path_or_url_for_links(target, path_or_url, options)
+      elsif target.is_a?(BasicObj)
+        path_or_url_for_objs(target, path_or_url, options)
+      elsif target.respond_to?(:first)
+        if target.first.is_a?(Link)
+          path_or_url_for_links(target.first, path_or_url, options)
+        else
+          return LINK_TO_EMPTY_LINKLIST
+        end
+      elsif target.is_a?(Binary)
+        binary = target
+        main_app.public_send("fiona7_blob_#{path_or_url}", {id: binary.send(:id), name: binary.filename})
+      else
+        raise "scrivito_path or scrivito_url was called with an instance of #{target.class}. "+
+          "It must only be called with a descendant of Scrivito::BasicObj or a Link or a non-empty LinkList."
+      end
+    end
+
+    # patch router to output proper binary urls fo uploaded files
+    def path_or_url_for_objs(obj, path_or_url, options = {})
+      permalink = obj.permalink
+      if permalink
+        main_app.public_send("scrivito_permalink_#{path_or_url}", options.merge(:permalink => permalink))
+      elsif obj.homepage?
+        main_app.public_send("scrivito_root_#{path_or_url}", options)
+      else
+        if obj.binary? && editing_context.display_mode != "editing"
+          if obj.binary
+            main_app.public_send("fiona7_blob_#{path_or_url}", {id: obj.binary.send(:id), name: obj.binary.filename})
+          else
+            LINK_TO_EMPTY_BLOB
+          end
+        else
+          main_app.public_send(
+            "scrivito_id_#{path_or_url}",
+            options.merge(
+              id: obj.id,
+              slug: obj.slug.presence
+            )
+          )
+        end
+      end
+    end
+  end
+end
+

data/lib/fiona7/scrivito_patches/controller_actions.rb

@@ -0,0 +1,14 @@
+require 'scrivito/controller_actions'
+
+module Scrivito
+  module ControllerActions
+    # different handling of binary objs
+    def deliver_file
+      if binary = @obj.binary
+        redirect_to fiona7_blob_path(id: binary.send(:id), name: binary.filename), :status => :moved_permanently
+      else
+      render text: 'Empty Blob', status: 404
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/link_parser.rb

@@ -0,0 +1,22 @@
+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'
+      )
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/migrator.rb

@@ -0,0 +1,13 @@
+require 'scrivito/migrations/migrator'
+
+
+module Scrivito
+  module Migrations
+    class Migrator
+      # remove locking etc.
+      def remove_workspace_with(&block)
+        yield
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/obj_class.rb

@@ -0,0 +1,16 @@
+require 'scrivito/obj_class'
+
+module Scrivito
+  class ObjClass
+    # there are no legacy types.
+    def is_binary
+      raise ScrivitoError,
+        %(`is_binary' and `binary?' can only be called on ObjClasses with a legacy_type.)
+    end
+    alias_method :binary?, :is_binary
+
+    def legacy_type?
+      false
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/type_computer.rb

@@ -0,0 +1,25 @@
+require 'scrivito/type_computer'
+
+module Scrivito
+  class TypeComputer
+    private
+    # In legacy mode we allow for an objects inside global namespace and Scrivito:: namespace
+    def load_class(obj_class)
+      klass = nil
+      begin
+        klass = obj_class.constantize
+      rescue NameError
+      end
+      return klass if klass && inherits_from_base?(klass)
+
+      if Fiona7.mode == :legacy
+        obj_class = "Scrivito::#{obj_class}"
+        begin
+          klass = obj_class.safe_constantize
+        rescue NameError
+        end
+        return klass if klass && inherits_from_base?(klass)
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/workspace.rb

@@ -0,0 +1,12 @@
+require 'scrivito/workspace'
+
+module Scrivito
+  class Workspace
+    # Backport a "solution" for broken diff view
+    def base_revision
+      if base_revision_id
+        @base_revision ||= Revision.new(id: base_revision_id, content_state: base_content_state, workspace: self)
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_user.rb

@@ -0,0 +1,44 @@
+module Fiona7
+  class ScrivitoUser
+    def self.define(rsession_user)
+      Scrivito::User.define(rsession_user.user_name) do |user_definition|
+        #
+        # Define how this user should be presented in the UI.
+        #
+        user_definition.description { "#{rsession_user.user_name}" }
+
+        # :-)
+        user_definition.can_always(:read, :workspace)
+
+        # workspaces can only be selected
+        user_definition.can_never(:create, :workspace)
+
+        # any write operation
+        user_definition.can_always(:write, :workspace)
+
+        # only root can publish rtc
+        if rsession_user.superuser?
+          user_definition.can_always(:publish, :workspace) 
+        else
+          user_definition.can_never(:publish, :workspace) 
+        end
+
+        #
+        # Below, we define the publishing restrictions related to 'Obj's for this user.
+        # The restriction callbacks should either return nothing (the 'Obj' may be published),
+        # or a string describing why the 'Obj' cannot be published by this user.
+        #
+        # Here, the '_path' attribute of a changed 'Obj' is used to determine
+        # whether the user is trying to publish changes made to a particular website
+        # section, here "investor relations", which requires a special permission.
+        #
+        user_definition.restrict_obj_publish(using: :_path) do |path|
+          obj = Fiona7::WriteObj.find_by_path(path)
+          if !obj || !obj.permission.release?(rsession_user.user_name)
+            I18n.t(:"fiona7.publish_permission_resticted", path: path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fiona7/search_engine.rb

@@ -0,0 +1,20 @@
+module Fiona7
+  class SearchEngine
+    def initialize(klass, query, offset, limit, sort, order)
+      @klass = klass
+      @query = query
+      @offset, @limit = offset, limit
+      @sort, @order = sort, order
+
+      @count = 0
+    end
+
+    def total
+      @count
+    end
+
+    def results
+      raise "Not implemented"
+    end
+  end
+end

data/lib/fiona7/type_register.rb

@@ -0,0 +1,140 @@
+require 'set'
+
+module Fiona7
+  class TypeRegister
+    TYPE_MAP = {
+      link:           :linklist,
+      reference:      :linklist,
+      referencelist:  :linklist,
+      widget:         :linklist,
+      binary:         :linklist
+    }
+
+    class << self
+      def instance
+        self.new
+      end
+    end
+
+    class ObjClass < Struct.new('ObjClass', :name, :type, :attributes)
+    end
+
+    class Attribute < Struct.new(:real_name, :virtual_name, :real_type, :virtual_type, :values)
+    end
+
+    def cached_type(obj_class_name)
+      @@cached_type ||= {}
+      @@cached_type[obj_class_name.to_s] ||= ObjClass.new.tap do |obj_class|
+        cms_class      = RailsConnector::ObjClass.find_by_obj_class_name(obj_class_name)
+        obj_class.name = cms_class.name
+        obj_class.type = cms_class.obj_type
+
+        attributes = Set.new
+        cms_class.custom_attributes.each do |real_name, cms_attribute|
+          real_name = real_name.to_sym
+
+          next if real_name == :X_widget_pool
+
+          if Fiona7.mode == :standalone
+            virtual_name = real_name.to_s.sub(/^s_#{Regexp.escape obj_class_name}__/, '').to_sym
+          elsif Fiona7.mode == :legacy
+            # X_blob simulates blob attribute
+            if real_name == :X_blob
+              virtual_name = :blob
+            else
+              virtual_name = real_name.to_sym
+            end
+          else
+            raise "Invalid Fiona7.mode = #{Fiona7.mode}"
+          end
+
+          real_type      = cms_attribute.attribute_type.to_sym
+          virtual_type   = ::JSON.parse(cms_attribute.help_text(:de))['type'].to_sym rescue nil
+          virtual_type ||= real_type
+
+          # real_type = virtual_type in this case
+          if [:enum, :multienum].include?(real_type)
+            values = cms_attribute.values
+          else
+            values = nil
+          end
+
+          attributes << Attribute.new(real_name, virtual_name, real_type, virtual_type, values)
+        end
+
+        if Fiona7.mode == :legacy
+          # include built-in title and body
+          attributes << Attribute.new(:title, :title, :string, :string, nil)
+          if cms_class.obj_type != "image" && cms_class.obj_type != "generic"
+            attributes << Attribute.new(:body, :body, :html, :html, nil)
+          end
+        end
+
+        obj_class.attributes = attributes.to_a
+      end
+    end
+
+    def invalidate_cached_type(obj_class_name)
+      @@cached_type.delete(obj_class_name.to_s)
+      # clear reactor cache as well
+      RailsConnector::Meta::EagerLoader.instance.forget_obj_class(obj_class_name)
+    end
+
+    def annotated_attributes(obj_class_name)
+      obj_class = cached_type(obj_class_name)
+      raise "Unknown obj_class: #{obj_class_name}" unless obj_class
+      obj_class.attributes
+    end
+
+    def attributes(obj_class_name)
+      raise "Deprecated"
+    end
+
+    def obj_type(obj_class_name)
+      self.cached_type(obj_class_name).type
+    end
+
+    def attribute_type(obj_class_name, attribute_name)
+      attribute = self.cached_type(obj_class_name).attributes.find {|a| a.virtual_name.to_s == attribute_name.to_s }
+
+      if attribute
+        attribute.virtual_type
+      else
+        raise "unknown attribute: #{attribute_name} in #{obj_class_name}"
+      end
+    end
+
+    def real_attribute_name(obj_class_name, attribute_name)
+      if Fiona7.mode == :standalone
+        :"s_#{obj_class_name}__#{attribute_name}"
+      elsif Fiona7.mode == :legacy
+        # blob attribute is always mapped to X_blob attribute if present
+        if attribute_name.to_sym == :blob
+          :X_blob
+        else
+          attribute_name.to_sym
+        end
+      else
+        raise "Invalid Fiona7.mode = #{Fiona7.mode}"
+      end
+    end
+
+    def virtual_attribute_name(obj_class_name, attribute_name)
+      attribute_name.to_s.sub("s_#{obj_class_name}__", '').to_sym
+    end
+
+    def attribute_real_type(obj_class_name, attribute_name)
+      attribute = self.cached_type(obj_class_name).attributes.find {|a| a.virtual_name.to_s == attribute_name.to_s }
+
+      if attribute
+        attribute.real_type
+      else
+        raise "unknown attribute: #{attribute_name} in #{obj_class_name}"
+      end
+    end
+
+    def map_virtual_to_real_type(virtual_type)
+      TYPE_MAP[virtual_type.to_sym] || virtual_type.to_sym
+    end
+  end
+end