infopark_fiona7 0.30.0.1

data/lib/fiona7/recursive_link_resolver.rb

@@ -0,0 +1,93 @@
+module Fiona7
+  class RecursiveLinkResolver
+    attr_reader :id_map, :path_map
+
+    def initialize(klass)
+      @processed_ids = Set[]
+      @id_map = {}
+      @path_map = {}
+      @klass = klass
+    end
+
+    def resolve(obj)
+      resolve_recursive([obj])
+    end
+
+    protected
+    def resolve_recursive(remaining_objects)
+      return if remaining_objects.empty?
+      return resolve_recursive(process_objects(remaining_objects))
+    end
+
+
+    def process_objects(objects)
+      found_objects = []
+
+      widget_id_to_obj_id_map = {}
+
+      objects.each do |object|
+        widget_id_to_obj_id_map.merge!(widget_id_to_obj_id_map_from_object(object))
+      end
+
+      @processed_ids.merge(objects.map(&:id))
+
+      unprocessed_object_ids = filter_unprocessed_ids(widget_id_to_obj_id_map.values)
+      if !unprocessed_object_ids.empty?
+        found_objects = @klass.find(unprocessed_object_ids)
+
+        id_object_map = create_id_object_map(found_objects)
+
+        widget_id_to_obj_id_map.each do |widget_id, obj_id|
+          if fetched_object = id_object_map[obj_id]
+            @id_map[widget_id] = fetched_object.id
+            @path_map[widget_id] = fetched_object.path
+          end
+        end
+      end
+
+      found_objects
+    end
+
+    def widget_id_to_obj_id_map_from_object(object)
+      widget_id_to_obj_id_map = {}
+
+      object.attr_values.each do |_, value|
+        links_from_attribute = gather_links(value)
+        widget_id_to_obj_id_map.merge!(links_from_attribute)
+      end
+
+      widget_id_to_obj_id_map
+    end
+
+
+    def gather_links(attribute_value)
+      links = {}
+
+      if attribute_value.kind_of?(Array) && !attribute_value.empty? && attribute_value.all? {|c| c.kind_of?(Hash)}
+        attribute_value.each do |link|
+          if (title = link['title'].presence) && (id = link['destination'].to_i) != 0
+            links[title] = id
+          end
+        end
+      end
+
+      links
+    end
+
+    def filter_unprocessed_ids(object_ids)
+      unprocessed_ids = []
+      object_ids.each do |object_id|
+        unprocessed_ids << object_id unless @processed_ids.include?(object_id)
+      end
+      unprocessed_ids
+    end
+
+    def create_id_object_map(objects)
+      id_object_map = {}
+      objects.each do |object|
+        id_object_map[object.id] = object
+      end
+      id_object_map
+    end
+  end
+end

data/lib/fiona7/routers/content_service.rb

@@ -0,0 +1,19 @@
+require "fiona7/controllers/content_service/obj_controller"
+require "fiona7/controllers/content_service/workspace_controller"
+
+class Scrivito::ContentService
+  class << self
+    alias_method :original_query, :query
+    def query(path, payload, options={})
+      #$stdout.puts "DEBUG CS GET: #{path} < #{payload.inspect} >"
+      case path
+      when /\Aworkspaces\/query/
+        Fiona7::Controllers::ContentService::WorkspaceController.new.fetch(payload)
+      when /\Aobjs\/query/
+        Fiona7::Controllers::ContentService::ObjController.new.fetch_multiple(payload)
+      else
+        original_query(path, payload, options)
+      end
+    end
+  end
+end

data/lib/fiona7/routers/rest_api.rb

@@ -0,0 +1,135 @@
+require "fiona7/controllers/rest_api/obj_class_controller"
+require "fiona7/controllers/rest_api/obj_controller"
+require "fiona7/controllers/rest_api/blob_controller"
+require "fiona7/controllers/rest_api/workspace_controller"
+
+class Scrivito::CmsRestApi
+  class << self
+    alias_method :original_task_unaware_request, :task_unaware_request
+    def task_unaware_request(method, resource_path, payload = nil)
+      raise "Unexpected method #{method}" unless [:delete, :get, :post, :put].include?(method)
+      self.send(method, resource_path, payload)
+    end
+
+    alias_method :original_get, :get
+    def get(resource_path, payload = nil, options = nil)
+      @number_of_requests += 1 if resource_path == @count_requests
+
+      if !resource_path.start_with?('/')
+        resource_path = '/' + resource_path
+      end
+
+      #$stdout.puts "DEBUG GET: #{resource_path}"
+      case resource_path
+      when /\A\/?revisions\/[a-zA-Z0-9_-]+\/obj_classes\Z/, /\A\/?workspaces\/[a-zA-Z0-9_-]+\/obj_classes\Z/
+        Fiona7::Controllers::RestAPI::ObjClassController.new.all
+      when /\A\/?revisions\/[a-zA-Z0-9_-]+\/objs\/[a-zA-Z0-9_-]+\Z/
+        _, _, revision_id, _, obj_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::ObjController.new.fetch_by_id_from_revision(revision_id, obj_id)
+      when /\A\/?workspaces\Z/
+        Fiona7::Controllers::RestAPI::WorkspaceController.new.all
+      when /\A\/?workspaces\/[a-zA-Z0-9_-]+\/objs\/find_by_path/
+        _, _, workspace_id = *resource_path.split("/")
+        path = resource_path.match(/path=(.*)\Z/)[1]
+        Fiona7::Controllers::RestAPI::ObjController.new.fetch_by_path(workspace_id, path)
+      when /\A\/?workspaces\/[a-zA-Z0-9_-]+\/objs\/search/
+        _, _, workspace_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::ObjController.new.search(workspace_id, payload)
+      when /\A\/?workspaces\/[a-zA-Z0-9_-]+\/obj_classes\/[a-zA-z0-9_-]+\Z/
+        _, _, workspace_id, _, obj_class_name = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::ObjClassController.new.fetch(workspace_id, obj_class_name)
+      when /\A\/?workspaces\/[a-zA-Z0-9_-]+\Z/
+        _, _, workspace_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::WorkspaceController.new.fetch(workspace_id)
+      when /\A\/?workspaces\/[a-zA-Z0-9_-]+\/objs\/[a-zA-Z0-9_-]+\Z/
+        _, _, workspace_id, _, obj_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::ObjController.new.fetch_by_id(workspace_id, obj_id)
+      when /\A\/?blobs\/[a-zA-Z0-9_-]+\Z/
+        _, _, blob_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::BlobController.new.fetch(blob_id)
+      else
+        #$stdout.puts "GET: #{resource_path}"
+        original_get(resource_path, payload, options)
+      end
+    end
+
+    alias_method :original_delete, :delete
+    def delete(resource_path, payload = nil, options = nil)
+      @number_of_requests += 1 if resource_path == @count_requests
+
+      if !resource_path.start_with?('/')
+        resource_path = '/' + resource_path
+      end
+
+      case resource_path
+      when /\A\/?workspaces\Z/
+        true
+      when /\A\/?workspaces\/[a-zA-Z0-9_-]+\Z/
+        raise Scrivito::ScrivitoError, 'Delete operation unsupported for workspaces'
+        _, _, workspace_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::WorkspaceController.new.delete(workspace_id)
+      when /\A\/?workspaces\/[a-zA-Z0-9_-]+\/objs\/[a-zA-Z0-9_-]+\Z/
+        _, _, workspace_id, _, obj_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::ObjController.new.destroy(workspace_id, obj_id)
+      else
+        #$stdout.puts "DELETE: #{resource_path}"
+        original_delete(resource_path, payload, options)
+      end
+    end
+
+    alias_method :original_post, :post
+    def post(resource_path, payload, options = nil)
+      @number_of_requests += 1 if resource_path == @count_requests
+
+      if !resource_path.start_with?('/')
+        resource_path = '/' + resource_path
+      end
+
+      #$stdout.puts "DEBUG POST: #{resource_path}"
+      case resource_path
+      when /\A\/?workspaces\Z/
+        Fiona7::Controllers::RestAPI::WorkspaceController.new.create(payload)
+      when /\A\/?workspaces\/[a-zA-Z0-9]+\/obj_classes/
+        _, _, workspace_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::ObjClassController.new.create(workspace_id, payload)
+      when /\A\/?workspaces\/[a-zA-Z0-9]+\/objs/
+        _, _, workspace_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::ObjController.new.create(workspace_id, payload)
+      else
+        #$stdout.puts "POST: #{resource_path}"
+        original_post(resource_path, payload, options)
+      end
+    end
+
+    alias_method :original_put, :put
+    def put(resource_path, payload, options = nil)
+      @number_of_requests += 1 if resource_path == @count_requests
+
+      if !resource_path.start_with?('/')
+        resource_path = '/' + resource_path
+      end
+
+      #$stdout.puts "DEBUG PUT: #{resource_path}"
+      case resource_path
+      when /\A\/?workspaces\/[a-zA-Z0-9]+\/objs\/[a-zA-Z0-9]+\Z/
+        _, _, workspace_id, _, obj_id = *resource_path.split("/")
+        payload[:obj][:_id] = obj_id
+        Fiona7::Controllers::RestAPI::ObjController.new.update(workspace_id, payload)
+      when /\A\/?workspaces\/[a-zA-Z0-9]+\/obj_classes\/[a-zA-z0-9_-]+\Z/
+        _, _, workspace_id, _, obj_class_name = *resource_path.split("/")
+        payload[:obj_class][:name] = obj_class_name
+        Fiona7::Controllers::RestAPI::ObjClassController.new.update(workspace_id, payload)
+      when /\A\/?workspaces\/[a-zA-Z0-9]+\/publish/
+        _, _, workspace_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::WorkspaceController.new.publish(workspace_id)
+      when /\A\/?workspaces\/[a-zA-Z0-9]+\/rebase/
+        raise Scrivito::ScrivitoError, 'Rebase operation unsupported for workspaces'
+        _, _, workspace_id = *resource_path.split("/")
+        Fiona7::Controllers::RestAPI::WorkspaceController.new.publish(workspace_id)
+      else
+        #$stdout.puts "PUT: #{resource_path}"
+        original_put(resource_path, payload, options)
+      end
+    end
+  end
+end

data/lib/fiona7/routing_monkey_patch.rb

@@ -0,0 +1,33 @@
+module ActionDispatch
+  module Routing
+    class RouteSet #:nodoc:
+      def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
+        raise ArgumentError, "Invalid route name: '#{name}'" unless name.blank? || name.to_s.match(/^[_a-z]\w*$/i)
+
+        forbidden_paths = [::File.join(Gem.loaded_specs['scrivito_sdk'].full_gem_path, "config/cms_routes.rb"),
+          ::File.join(Gem.loaded_specs['infopark_fiona_connector'].full_gem_path, "config/cms_routes.rb")]
+
+        if caller.any? {|path| forbidden_paths.any? {|fp| path.include?(fp) } }
+          return  # bad dog scrivito/fiona_connector, bad dog! no cms_routes for you
+        end
+
+        if name && named_routes[name]
+
+          raise ArgumentError, "Invalid route name, already in use: '#{name}' \n" \
+            "You may have defined two routes with the same name using the `:as` option, or " \
+            "you may be overriding a route already defined by a resource with the same naming. " \
+            "For the latter, you can restrict the routes created with `resources` as explained here: \n" \
+            "http://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
+        end
+
+        path = build_path(conditions.delete(:path_info), requirements, SEPARATORS, anchor)
+        conditions = build_conditions(conditions, path.names.map { |x| x.to_sym })
+
+        route = @set.add_route(app, path, conditions, defaults, name)
+        named_routes[name] = route if name
+        route
+      end
+    end
+  end
+end
+

data/lib/fiona7/scrivito_patches/attribute_content.rb

@@ -0,0 +1,19 @@
+require 'scrivito/attribute_content'
+
+module Scrivito
+  module AttributeContent
+    module ClassMethods
+      # This is new. It returns the obj class name for given subclass of BasicObj or nil
+      def obj_class_name
+        self.name.split('::').last if self != Obj && self != ::Obj
+      end
+
+      # Patch to work-around Scrivito::... classes in legacy mode
+      def with_default_obj_class(attributes)
+        return attributes if attributes[:_obj_class] || attributes["_obj_class"]
+        return attributes if type_computer.special_class?(self)
+        attributes.merge("_obj_class" => self.obj_class_name)
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/basic_obj.rb

@@ -0,0 +1,92 @@
+require 'scrivito/basic_obj'
+
+module Scrivito
+  class BasicObj
+    # Type computer computes with global Obj by default
+    # which in legacy mode belongs to fiona_connector
+    # Therefore we limit the scope of the search to Scrivito::Obj
+    def self.type_computer
+      @_type_computer ||= TypeComputer.new(Scrivito::BasicObj, Obj)
+    end
+
+    # to_param should only return strings and our ids are numbers
+    def to_param
+      id.to_s
+    end
+
+    # Originally this method checks for conflicts
+    # which are impossible here, hence the method is stubbed out
+    def publishable?
+      # TODO: implement CM validations here
+      # FIXME: this can be solved much faster in PublishChecker
+      self.id && Fiona7::EditedObj.find(self.id).permission.release?
+    end
+
+    # Original implentation reads file extension from name
+    # but since dots are not allowed in the names
+    # it has to be worked around.
+    def file_extension
+      if (blob = find_blob)
+        blob.file_extension
+      else
+        ""
+      end
+    end
+
+    def fiona_obj
+      @fiona_obj ||= ::RailsConnector::BasicObj.find(self.id)
+    end
+
+    # Patch to allow reverting in rtc workspace
+    def assert_revertable
+      if workspace.id != 'rtc'
+        raise ScrivitoError, "cannot revert changes, since obj is not from valid revertable workspace."
+      end
+      if modification == Modification::NEW || modification == Modification::DELETED
+        raise ScrivitoError, "cannot revert changes, since obj is #{modification}."
+      end
+    end
+
+    # This method may be called like this: image_tag(obj) in a view
+    # which is fundamentally broken. image_tag(scrivito_path(obj))
+    # should be called instead.
+    def body_data_url
+      if binary? && read_attribute('blob')
+        raise "This method is not supported by Fiona7 and should not be called, try using Scrivito::Binary#content or scrivito_url(obj) when appropriate"
+      end
+    end
+
+    # Originally this method refers to the global Obj via ::Obj
+    def self.where(field, operator, value, boost = nil)
+      assert_not_basic_obj('.where')
+      if self == Obj || self == ::Obj
+        Workspace.current.objs.where(field, operator, value, boost)
+      else
+        assert_has_obj_class('.where')
+        Workspace.current.objs.where(:_obj_class, :equals, obj_class_name)
+        .and(field, operator, value, boost)
+      end
+    end
+
+    # Originally this method refers to the global Obj via ::Obj
+    def self.all
+      assert_not_basic_obj('.all')
+      if self == Obj || self == ::Obj
+        Workspace.current.objs.all
+      else
+        assert_has_obj_class('.all')
+        find_all_by_obj_class(obj_class_name)
+      end
+    end
+
+    class << self
+
+      def assert_has_obj_class(method_name)
+        unless Workspace.current.obj_classes[obj_class_name].present?
+          raise ScrivitoError, "#{name} has no corresponding ObjClass."
+            + " Please use Obj.#{method_name} instead."
+        end
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/basic_widget.rb

@@ -0,0 +1,14 @@
+require 'scrivito/basic_widget'
+
+module Scrivito
+  class BasicWidget
+    # patch hash to handle numeric ids
+    def hash
+      if @obj && @id
+        (id.to_s + obj.id.to_s).hash
+      else
+        super
+      end
+    end
+  end
+end

data/lib/fiona7/scrivito_patches/binary.rb

@@ -0,0 +1,55 @@
+require 'scrivito/binary'
+
+module Scrivito
+  # This class had been reworked to support uploads directly
+  # into CMS and not into S3
+  class Binary
+    # new implementation
+    def content_type
+      if shadow_obj
+        shadow_obj.mime_type
+      end
+    end
+
+    def content_length
+      if shadow_obj
+        shadow_obj.body_length
+      else
+        0
+      end
+    end
+
+    def filename
+      if shadow_obj
+        shadow_obj.name + '.' + shadow_obj.file_extension
+      end
+    end
+
+    # New API call. Allows to read the extension of the stored file.
+    def file_extension
+      if shadow_obj
+        shadow_obj.file_extension
+      end
+    end
+
+    # New API call. Allows to access the contents of the blob.
+    def content
+      if shadow_obj
+        shadow_obj.body
+      end
+    end
+
+    def url
+      ActiveSupport::Deprecation.warn("This method should never be called. Use scrivito_path or scrvito_url whenever possible")
+      if shadow_obj
+        Rails.application.routes.url_helpers.fiona7_blob_path(id: @id, name: self.filename)
+      end
+    end
+
+    private
+    def shadow_obj
+      @shadow_obj ||= Fiona7::InternalReleasedObj.find(@id.to_i) if @id.to_i != 0
+    end
+  end
+end
+