infopark_fiona7 0.30.0.2 → 0.70.0.1

data/lib/fiona7/scrivito_patches/client_config.rb

@@ -1,19 +0,0 @@
-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_backend.rb

@@ -0,0 +1,48 @@
+require 'scrivito/cms_backend'
+
+module Scrivito
+  class CmsBackend
+    def die_content_service
+      # TODO: remove this
+      false
+    end
+
+    # prevent the use of local URLs (localhost:7104) from cache
+    # when running under a server
+    def find_blob_data_from_cache(id, access, verb, transformation_definition)
+      cache_key = blob_data_cache_key(normalize_blob_id(id), access, verb, transformation_definition)
+      data = CmsDataCache.cache.read(cache_key)
+
+      if !data.nil? && Fiona7::Middleware::ServerDetectionMiddleware.server_detected?
+        tainted_data = data['url'] =~ /\Ahttps?:\/\/localhost:7104/
+
+        if tainted_data
+          nil
+        else
+          data
+        end
+      else
+        data
+      end
+    end
+
+    # prevent real get requests since we run everything locally
+    def request_blob_metadata_from_s3(url)
+      @query_counter += 1
+
+      blob_id = /\/_b\/([0-9]+)/.match(url)[1]
+
+      raise ScrivitoError, "Unexpected 's3' url: #{url}" unless blob_id.present?
+
+      rest_api_meta_data = Fiona7::Controllers::RestAPI::BlobController.new.metadata(blob_id)
+
+      meta_data = {}
+      meta_data[:content_type]   = rest_api_meta_data['meta_data']['content_type'].last
+      meta_data[:content_length] = rest_api_meta_data['meta_data']['content_length'].last
+      meta_data[:cache_control]  = 'no-transform,public,max-age=300,s-maxage=900'
+
+      meta_data
+    end
+
+  end
+end

data/lib/fiona7/scrivito_patches/cms_field_tag.rb

@@ -0,0 +1,19 @@
+require 'scrivito/cms_field_tag'
+
+module Scrivito
+  class CmsFieldTag
+    # support shadowclassing
+    def build_valid_widget_classes
+      obj_or_widget.valid_widget_ruby_classes_for(field_name).map do |widget_class|
+        real_widget_class_name = widget_class.name
+        fake_widget_class = widget_class.to_s
+        widget_class = widget_class.to_s
+        {
+          name: fake_widget_class,
+          description: description_for_widget_class(real_widget_class_name),
+        }
+      end
+    end
+  end
+end
+

data/lib/fiona7/scrivito_patches/cms_rest_api.rb

@@ -3,9 +3,26 @@ 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
+    def self.upload_file(file, obj_id)
+      # TODO: code deduplication with obj builder
+      parent = Fiona7::WriteObj.find(obj_id.to_i)
+      ext       = ::File.extname(file.path).to_s[1..-1]
+      name      = ::File.basename(file.path, '.' + ext.to_s)
+      obj_class = if ['jpg', 'jpeg', 'gif', 'png', 'tif', 'tiff'].include?(ext)
+                    'X_Image'
+                  else
+                    'X_Generic'
+                  end
+
+      raise Scrivito::ScrivitoError.new("File extension of uploaded file cannot be identified", 422) if ext.nil?
+
+      upload = Fiona7::WriteObj.upload(file, ext, {name: name, parent: parent, obj_class: obj_class}).tap(&:release!)
+      encoded_id = '%032d' % upload.id
+      {'id' => encoded_id}
+    end
+
+    def self.activate_upload(*args)
+      raise "This method is not implemented"
     end
   end
 end

data/lib/fiona7/scrivito_patches/cms_routing.rb

@@ -2,12 +2,26 @@ 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
+        html.to_str.gsub(%r{\bobjid:([a-f0-9]{4,16})\b([^"']*)}) do
           if obj = Obj.find_by_id($1)
-            path_or_url(obj, "path")
+            options = {}
+
+            if $2.present?
+              begin
+                uri = URI.parse($2)
+                options.merge!(extract_query(uri))
+                options['anchor'] = uri.fragment
+              rescue
+              end
+            end
+
+            if editing_context.display_mode == 'editing'
+              id_path_or_url_for_objs(obj, :path, options)
+            else
+              path_or_url(obj, :path, options)
+            end
           else
             "#__target_object_not_reachable"
           end
@@ -15,11 +29,10 @@ module Scrivito
       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)
+      elsif target.is_a?(Obj) || 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)
@@ -28,37 +41,10 @@ module Scrivito
           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})
+        binary_url(target)
       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
+          "It must only be called with an Obj or a Link or a non-empty LinkList."
       end
     end
   end

data/lib/fiona7/scrivito_patches/controller_actions.rb

@@ -2,13 +2,5 @@ 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/migrator.rb

@@ -8,6 +8,10 @@ module Scrivito
       def remove_workspace_with(&block)
         yield
       end
+
+      def workspace
+        Workspace.find('rtc')
+      end
     end
   end
 end

data/lib/fiona7/scrivito_patches/objs_controller.rb

@@ -0,0 +1,18 @@
+module Scrivito
+  # trigger load
+  ObjsController
+  class ObjsController < WebserviceController
+
+    # optimized away
+    def is_outdated
+      @is_outdated = false
+    end
+
+    # optimized away
+    def conflicting_workspaces
+      @workspaces = []
+      render :workspaces
+    end
+
+  end
+end

data/lib/fiona7/scrivito_patches/type_computer.rb

@@ -3,23 +3,23 @@ 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
+
+    def load_class(obj_class_name)
       begin
-        klass = obj_class.constantize
+        klass = obj_class_name.constantize
+        klass = nil if !inherits_from_base?(klass)
       rescue NameError
+        klass = ::ShadowClasses.const_get(obj_class_name)
+        klass = nil if !inherits_from_base?(klass)
       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)
+      if !klass
+        klass = ::ShadowClasses.const_get(obj_class_name)
+        klass if inherits_from_base?(klass)
+      else
+        klass
       end
+    rescue NameError
     end
   end
 end

data/lib/fiona7/scrivito_patches/webservice_controller.rb

@@ -0,0 +1,21 @@
+module Scrivito
+
+  # trigger load
+  WebserviceController
+
+  class WebserviceController < ActionController::Base
+
+    # Workaround for https://github.com/rails/rails/issues/8832
+    def merge_correctly_parsed_json_params
+      if request.format.json?
+        body = request.body.read
+        request.body.rewind
+        params.merge!(ActiveSupport::JSON.decode(body)) if body.present? && !request.form_data?
+      end
+    rescue JSON::ParserError => e
+      # Rails TestRequest mixes up arguments, therefore ignore elements here
+      raise e unless Rails.env.test?
+    end
+  end
+
+end

data/lib/fiona7/scrivito_patches/workspace.rb

@@ -2,11 +2,14 @@ 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
+    # there are no conflicts.
+    def conflict_warning_for(*args)
+      []
+    end
+
+    # there are no outdated workspaces
+    def outdated?
+      false
     end
   end
 end

data/lib/fiona7/shadow_classes.rb

@@ -0,0 +1,74 @@
+module ShadowClassesSupport
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    alias_method :real_to_s, :to_s
+    # NOTE: this workaround is neccessary, because
+    # in many places scrivito_sdk assumes that
+    # class.name == obj_class_name which isn't
+    # true for shadow classes
+    # it breaks the bijection that scrivito_sdk
+    # expects, but injection is mostly ok
+    def to_s
+      self.name.sub(/\AShadowClasses::/, '')
+    end
+
+    def real_to_s
+      self.name
+    end
+  end
+end
+
+module ShadowClasses
+  def self.fetch(name,type)
+    # false skips inheritance chain, it checks only this module
+    if self.const_defined?(name, false)
+      self.const_get(name, false)
+    else
+      self.define(name,type)
+    end
+  end
+
+  def self.define(name,type)
+    if name =~ /::/
+      raise "Invalid name: #{name}, nesting of classes not allowed"
+    end
+
+    if type == 'Obj'
+      if name == 'Obj'
+        self.const_set(name, scrivito_obj_class)
+      else 
+        self.const_set(
+          name,
+          Class.new(scrivito_obj_class) do
+            include ::ShadowClassesSupport
+          end
+        )
+      end
+    elsif type == 'Widget'
+      parent_class = 'Widget'.safe_constantize || Scrivito::BasicWidget
+      self.const_set(
+        name,
+        Class.new(parent_class) do
+          include ::ShadowClassesSupport
+        end
+      )
+    end
+
+  end
+
+  def self.scrivito_obj_class
+    if !::Scrivito.const_defined?('Obj', false)
+      if Fiona7.mode == :standalone
+        ::Scrivito.const_set('Obj', ::Obj)
+      elsif Fiona7.mode == :legacy
+        ::Scrivito.const_set('Obj', Class.new(::Scrivito::BasicObj))
+      else
+        raise "Invalid Fiona7.mode = #{Fiona7.mode}"
+      end
+    end
+    ::Scrivito.const_get('Obj', false)
+  end
+end

data/lib/fiona7/table_switcher.rb

@@ -0,0 +1,39 @@
+module Fiona7
+
+  class TableSwitcher
+    attr_accessor :klass, :table_suffix, :table_prefix, :table_name
+
+    def initialize(klass, table_suffix)
+      self.klass = klass
+      self.table_prefix = klass.table_name_prefix
+      self.table_suffix = table_suffix
+      self.table_name = "#{self.table_prefix}#{self.table_suffix}"
+    end
+
+    def switch
+      if klass.table_name != self.table_name 
+        value = self.table_name
+        klass_name = klass.name
+        Rails.logger.debug "Switching table name to #{value} on #{self.klass.name}"
+        # TODO: cache values for two modes somehow? (to improve performance)
+        # NOTE: we abuse the fact that the two tables have identical schemes
+        # and only swap out the table name sneakly, skipping DB schema lookup
+        # and also reloading of attributes, which can break the app
+        # (by removing primary key accessor :id)
+        klass.instance_eval do
+          connection.clear_cache!
+          @table_name        = value
+          @quoted_table_name = nil
+          @arel_table        = nil
+          @sequence_name     = nil unless defined?(@explicit_sequence_name) && @explicit_sequence_name
+          @relation          = ActiveRecord::Relation.create(self, arel_table)
+
+          # reset associations, otherwise they go out of sync
+          has_many :children, :class_name => klass_name, :foreign_key => 'parent_obj_id'
+          belongs_to :parent, :class_name => klass_name, :foreign_key => 'parent_obj_id'
+        end
+      end
+    end
+
+  end
+end