infopark_fiona7 1.1.0.0.10 → 1.2.0.0.0

data/lib/fiona7/scrivito_patches/attribute_content.rb

@@ -17,7 +17,7 @@ module Scrivito
 
       # support shadow classes
       def description_for_editor
-        to_s
+        to_s.titleize
       end
 
       def register_attribute_definitions(obj_class)

data/lib/fiona7/scrivito_patches/attribute_serializer.rb

@@ -5,12 +5,33 @@ module Scrivito
     def serialize_binary_value(attribute_value, attribute_definition)
       case attribute_value
       when File           then attribute_value
-      when FutureBinary   then attribute_value.file_to_upload
+      when FutureBinary   then special_handling_of_future_binary(attribute_value, attribute_definition)
       when UploadedBinary then attribute_value.params
       else
         raise_validation_error(attribute_definition.name,
                                'an instance of File, Scrivito::UploadedBinary or nil', attribute_value)
       end
     end
+
+    protected
+    def special_handling_of_future_binary(future_binary, attribute_definition)
+      if future_binary.file_to_upload
+        # The easy case: just upload the file directly, it works
+        future_binary.file_to_upload
+      elsif future_binary.id_to_copy
+        # The hard case: magic blob copy/rename needs to happen
+        {
+          obj_id:         obj_id,
+          attr_name:      attribute_definition.name.to_s,
+          id_to_copy:     future_binary.id_to_copy,
+          filename:       future_binary.filename,
+          content_type:   future_binary.content_type
+        }
+      else
+        # The unknown case: ???
+        Rails.logger.error("Unsure how to proceed with an upload of #{future_binary.inspect}")
+        nil
+      end
+    end
   end
 end

data/lib/fiona7/scrivito_patches/basic_obj.rb

@@ -21,11 +21,6 @@ module Scrivito
         "Already modified in workspace #{target_workspace.id}"
     end
 
-    def copy_binaries(attributes)
-      # TODO: what to do?
-      attributes
-    end
-
     # Originally this method checks for conflicts
     # which are impossible here, hence the method is stubbed out
     def publishable?
@@ -45,6 +40,33 @@ module Scrivito
       end
     end
 
+    # Original implementation mishandles attribute => [type, value]
+    def copy_binaries(attributes)
+      attribute_defintions = self.class.find_attribute_definitions(obj_class)
+      destination_obj_id = attributes.fetch(:_id)
+
+      Hash[attributes.map do |name, value|
+        # Here is the change
+        if value && attribute_defintions[name].try(:type) == 'binary' && (binary = self[name])
+          [name, ['binary', copy_binary(destination_obj_id, binary)]]
+        else
+          [name, value]
+        end
+      end]
+    end
+
+    # Original implmentation uses the blob copy API
+    # This is completely unneccessary, as the required
+    # logic is already possible implemented similar to FutureBinary
+    def copy_binary(destination_obj_id, binary)
+      {
+        obj_id:         destination_obj_id,
+        id_to_copy:     binary.id,
+        filename:       binary.filename,
+        content_type:   binary.content_type
+      }.stringify_keys
+    end
+
     def fiona_obj
       @fiona_obj ||= ::RailsConnector::BasicObj.find(self.id)
     end

data/lib/fiona7/scrivito_patches/cms_backend.rb

@@ -1,11 +1,11 @@
 require 'scrivito/cms_backend'
 
 module Scrivito
-  class CmsBackend
+  module CmsBackend
     # 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)
+    def self.find_blob_data_from_cache(id, access, verb, options)
+      cache_key = blob_data_cache_key(normalize_blob_id(id), access, verb, options)
       data = CmsDataCache.cache.read(cache_key)
 
       if !data.nil? && Fiona7::Middleware::ServerDetectionMiddleware.server_detected?
@@ -20,24 +20,5 @@ module Scrivito
         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_rest_api.rb

@@ -1,4 +1,5 @@
 require 'scrivito/cms_rest_api.rb'
+require 'fiona7/blob_id_generator'
 
 module Scrivito
   class CmsRestApi
@@ -18,7 +19,7 @@ module Scrivito
       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
+      encoded_id = Fiona7::BlobIdGenerator.new(upload.id, upload.last_changed).call
       {'id' => encoded_id}
     end
 

data/lib/fiona7/scrivito_patches/cms_routing.rb

@@ -53,7 +53,7 @@ module Scrivito
     # Use fiona connector permalinks in legacy mode
     def path_or_url_for_objs(obj, path_or_url, options)
       permalink = obj.permalink
-      if permalink && route_defined?(:permalink)
+      if permalink && route_defined?(:permalink) && permalink.split('/').first != 'scrivito'
 
         if Fiona7.mode == :legacy
           context.public_send("cms_permalink_#{path_or_url}", options.merge(:permalink => permalink))
@@ -64,7 +64,7 @@ module Scrivito
         use_route(:homepage, path_or_url, options)
       elsif obj.binary?
         # use fiona connector routes when possible
-        if Fiona7.mode == :legacy
+        if Fiona7.mode == :legacy && self.image_options.blank?
           if binary = obj.binary
             params = {
               id: obj.id,

data/lib/fiona7/scrivito_patches/model_library.rb

@@ -10,10 +10,10 @@ module Scrivito
       return model_class if model_class.ancestors.include?(base_class)
 
       if Fiona7.mode == :legacy && model_class.respond_to?(:shadow_class)
-        model_class = model_class.shadow_class
-        model_class if model_class.ancestors.include?(base_class)
+        model_class = model_class.shadow_class rescue nil
+        model_class if model_class && model_class.ancestors.include?(base_class)
       end
-    rescue NameError
+    rescue LoadError
     end
   end
 end

data/lib/fiona7/scrivito_patches/page_config.rb

@@ -5,7 +5,7 @@ module Scrivito
     def current_page_config
       # TODO: add permission info
       return {} unless obj
-      {
+      config = {
         id: obj.id,
         path: obj.path,
         obj_class: obj.obj_class,
@@ -16,6 +16,26 @@ module Scrivito
         parent_path: obj.parent_path,
         restriction_messages: editor.restriction_messages_for(obj),
       }
+      if ::Fiona7.workflows_enabled?
+        fiona_obj = obj.fiona_obj
+        if fiona_obj.workflow.present?
+          # without a workflow or with workflows disabled this will be falsy
+          config[:workflow]         = true
+          # this just the returns the currently set editor
+          config[:editor]           = fiona_obj.editor
+          # this is the most important bit: when to disable the editing
+          # altough simple this implementation handles the following cases:
+          # 1. someone outside the workflow visits the page
+          # 2. a current editor within the workflow visits the page
+          # 3. someone within the workflow visits the page
+          config[:editing_disabled] = fiona_obj.editor != editor.id
+          # this contains validActionKeys from cms
+          # TODO: this should be implemented in reactor
+          config[:buttons]          = fiona_obj.send(:crul_obj).valid_actions
+        end
+      end
+
+      config
     end
   end
 end

data/lib/fiona7/scrivito_patches/preset_routes.rb

@@ -1,6 +1,18 @@
+require "scrivito/preset_routes"
+
 module Scrivito
   module PresetRoutes
-    def self.install_into(route_set)
+    mattr_accessor :delayed
+    self.delayed ||= {}
+
+    def self.install_delayed(route_set=nil)
+      delayed.each do |route, delayed_lambda|
+        delayed_lambda.call(route_set)
+      end
+    end
+
+    def self.install_into(route_set, do_the_install=false)
+      return unless do_the_install
       return if Scrivito::Configuration.scrivito_route_enabled?
 
       Scrivito::Configuration.with_scrivito_route_enabled do
@@ -22,7 +34,8 @@ module Scrivito
       end
     end
 
-    def self.install_slave_into(route_set)
+    def self.install_slave_into(route_set, do_the_install=false)
+      return unless do_the_install
       return if Scrivito::Configuration.scrivito_route_enabled?
 
       Scrivito::Configuration.with_scrivito_route_enabled do

data/lib/fiona7/scrivito_patches/routing_extensions.rb

@@ -1,3 +1,5 @@
+require "scrivito/routing_extensions"
+
 module Scrivito
 
 module RoutingExtensions
@@ -6,32 +8,43 @@ module RoutingExtensions
     assert_scrivito_route_enabled
     # @set is a ActionDispatch::Routing::RouteSet
     # see: http://git.io/v4UYF and http://git.io/v4UOI
-    route_set = @set
+    original_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,
+    # route_set is actually an optional parameter
+    # and should only be used in test scenarios
+    delayed = proc do |route_set|
+      route_set ||= original_route_set
+      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
+        else
+          raise error
+        end
       end
     end
+
+    if route_name == :permalink && false
+      PresetRoutes.delayed[route_name] = delayed
+    else
+      delayed.call(original_route_set)
+    end
   end
 
   private

data/lib/fiona7/scrivito_patches/workspace.rb

@@ -12,7 +12,7 @@ module Scrivito
       false
     end
 
-    # fix silly assumptions 
+    # properly handle the only two workspaces
     def self.use(id_or_title)
       self.current = if id_or_title =~ /(published|rtc)/
         find(id_or_title)
@@ -20,6 +20,8 @@ module Scrivito
         find_by_title(id_or_title) or
           raise ResourceNotFound, "Could not find #{self} with title #{id_or_title}"
       end
+    rescue ResourceNotFound
+      raise ResourceNotFound, %{Could not find #{self} with title or ID "#{id_or_title}"}
     end
   end
 end

data/lib/fiona7/super_object_finder.rb

@@ -0,0 +1,63 @@
+# This class allows to access objects linking to
+# given object, i.e. super objects
+#
+# It provides two modes of searching: preview nad live
+module Fiona7
+  class SuperObjectFinder
+    def initialize(model=::Fiona7::WriteObj, connection=nil, instance_name=RailsConnector::CmsBaseModel.instance_name)
+      @instance_name = instance_name
+      @conn          = connection || model.connection
+      @model         = model
+    end
+
+    def find(type=:preview, obj)
+      case type
+      when :preview
+        preview(obj)
+      when :live
+        live(obj)
+      else
+        raise ArgumentError, "Uknown type #{type.inspect} expected :preview or :ive"
+      end
+    end
+
+    # This method returns the results of search for objects
+    # in preview mode.
+    #
+    # This means that all objects that are reachable in preview
+    # are returned (unreleased, commited etc.)
+    def preview(obj)
+      query = "SELECT #{objects_table}.object_id FROM #{links_table} INNER JOIN #{objects_table} ON #{links_table}.content_id = #{objects_table}.edited_content_id WHERE #{links_table}.sub_object_id = #{obj.obj_id.to_i} #{self.obj_class_condition} UNION SELECT #{objects_table}.object_id FROM #{links_table} INNER JOIN #{objects_table} ON #{links_table}.content_id = #{objects_table}.committed_cont_id WHERE #{links_table}.sub_object_id = #{obj.obj_id.to_i} #{self.obj_class_condition} UNION SELECT #{objects_table}.object_id FROM #{links_table} INNER JOIN #{objects_table} ON #{links_table}.content_id = #{objects_table}.released_cont_id WHERE #{links_table}.sub_object_id = #{obj.obj_id.to_i} AND #{objects_table}.committed_cont_id IS NULL AND #{objects_table}.edited_content_id IS NULL #{self.obj_class_condition}"
+      ids = self.sql_query(query).to_a.flatten
+      @model.find(ids).select(&:exportable?)
+    end
+
+    # This method returns the results of search for objects
+    # in live mode.
+    #
+    # This means that only the objects that are reachable in
+    # live are returned, i.e. avaiable for outside world
+    def live(obj)
+      query = "SELECT #{objects_table}.object_id FROM #{links_table} INNER JOIN #{objects_table} ON #{links_table}.content_id = #{objects_table}.released_cont_id WHERE #{links_table}.sub_object_id = #{obj.obj_id.to_i} #{self.obj_class_condition}"
+      ids = self.sql_query(query).to_a.flatten
+      @model.find(ids).select(&:exportable?)
+    end
+
+    protected
+    def links_table
+      "#{@instance_name}_links"
+    end
+
+    def obj_class_condition
+      ""
+    end
+
+    def objects_table
+      "#{@instance_name}_objects"
+    end
+
+    def sql_query(query, *args)
+      @conn.execute(query, *args)
+    end
+  end
+end

data/lib/fiona7/type_register.rb

@@ -8,6 +8,9 @@ require "fiona7/attribute_name_mangler"
 
 
 module Fiona7
+  class TypeSystemError < ::ArgumentError
+  end
+
   class TypeRegister
     include Singleton
 
@@ -17,24 +20,35 @@ module Fiona7
       referencelist:  :linklist,
       widgetlist:     :linklist,
       binary:         :linklist,
+      number:         :string,
       stringlist:     :text
     }.freeze
 
     class TypeDefinition
       class Attribute < Struct.new(:name, :type, :real_name, :real_type, :values)
-        class Core < Struct.new(:name, :type)
-        end
-
         def eql?(other)
           other.kind_of?(self.class) &&
             self.name.eql?(other.name)
-            #Core.new(self.name, self.type).eql?(Core.new(other.name, other.type))
         end
 
         def hash
           return self.name.hash
-          #Core.new(self.name, self.type).hash
         end
+
+        def values_set
+          return @values_set if defined?(@values_set)
+
+          if self.values.present?
+            @values_set = self.values.to_set
+          else
+            @values_set = Set[]
+          end
+
+          return @values_set
+        end
+
+        protected
+        attr_writer :name, :type, :real_name, :real_type, :values
       end
 
       attr_accessor :name
@@ -143,7 +157,6 @@ module Fiona7
     end
 
     def ad_hoc_synchronize(type_definition)
-      #puts "Ad hoc synchronize of #{type_definition.name}"
       obj_class = type_definition.name
 
       existing_definition = self.usr_defs[obj_class]
@@ -157,7 +170,7 @@ module Fiona7
         self.cms_def_present?(obj_class) &&
         defs_compatible?(self.cms_defs[obj_class], type_definition)
 
-      puts "Ad hoc synchronization required of #{type_definition.name}"
+      Rails.logger.warn "Ad hoc synchronization required of #{type_definition.name}"
 
       self.synchronize(obj_class)
       self.load(obj_class)
@@ -196,13 +209,25 @@ module Fiona7
           # has a proper definition
           true
         else
-          #raise "Attribute types for #{attr_name} incompatible: CMS uses #{cms_type} but the application provided #{usr_type}"
-          puts "Attribute types for #{attr_name} incompatible: CMS uses #{cms_type} but the application provided #{usr_type}"
+          message = "Attribute types for #{attr_name} incompatible: CMS uses #{cms_type} but the application provided #{usr_type}"
+          if ::Fiona7.config.dont_yell_at_me_for_abusing_attributes
+            Rails.logger.error("TYPE SYNCHRONIZATION: " + message)
+          else
+            raise TypeSystemError, message
+          end
+
           false
         end
       end
     end
 
+    def value_lists_compatabile?(usr_attr, cms_attr)
+      return true unless [:multienum, :enum].include?(usr_attr.type)
+      return true unless [:multienum, :enum].include?(cms_attr.type)
+
+      return cms_attr.values_set.superset?(usr_attr.values_set)
+    end
+
     def defs_compatible?(cms_def, usr_def)
       cms_attr_map = {}
       cms_def.attrs.each do |attr|
@@ -212,6 +237,7 @@ module Fiona7
       usr_def.attrs.each do |attr|
         return false if !cms_attr_map[attr.name]
         return false if !type_compatible?(attr.name, cms_attr_map[attr.name].type, attr.type)
+        return false if !value_lists_compatabile?(attr, cms_attr_map[attr.name])
       end
 
       return true