infopark_fiona_connector 7.0.1 → 7.0.1.5.2.3.rc4

data/lib/rails_connector/blob.rb

@@ -11,7 +11,9 @@ module RailsConnector
         select(:blob_name, :blob_length).find(primary_key)
       end
 
-      alias_method_chain :find, :excluded_blob_data
+      alias_method :find_without_excluded_blob_data, :find
+      alias_method :find, :find_with_excluded_blob_data
+
     end
 
     def length

data/lib/rails_connector/blob_mapping.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module RailsConnector
+  class BlobMapping < CmsBaseModel
+    def self.exists?
+      self.table_exists?
+    end
+
+    def self.get_fingerprint(name)
+      find_by_blob_name(name).fingerprint
+    end
+
+    def self.get_fingerprint_map(blob_names)
+      Hash[self.where(:blob_name => blob_names).select([:blob_name, :fingerprint]).map {|b| [b.blob_name, b.fingerprint] }]
+    end
+  end
+end

data/lib/rails_connector/channel.rb

@@ -0,0 +1,19 @@
+module RailsConnector
+  class Channel < CmsBaseModel
+    self.primary_key = "channel_name"
+
+    def self.table_name
+      "#{table_name_prefix}" "channels"
+    end
+
+    has_many :news, :class_name => 'RailsConnector::News', :foreign_key => 'channel_name'
+    has_many :active_news,
+      lambda { where(['valid_from <= :now AND valid_until >= :now', {:now => Time.now.to_s(:number)}]) },
+      :class_name => 'RailsConnector::News', :foreign_key => 'channel_name'
+
+    has_many :objects, :through => :news
+
+    scope :with_prefix, -> (prefix) {where(["channel_name LIKE ?", "#{prefix}%"])}
+
+  end
+end

data/lib/rails_connector/cms_accessible.rb

@@ -8,7 +8,7 @@ module RailsConnector
     # Filter method to load a CMS object.
     #
     # To require the loading for all actions, use this in your controllers:
-    #   before_filter :load_object
+    #   before_action :load_object
     def load_object
       CmsEnv.new(request.env).load
       loaded_obj = request.env[CmsEnv::OBJ_ENV_KEY]
@@ -20,15 +20,14 @@ module RailsConnector
     # not, a 410 Gone error message will be generate (by calling render_obj_error).
     #
     # To require the check for all actions, use this in your controllers:
-    #   before_filter :load_object
-    #   before_filter :ensure_object_is_active
+    #   before_action :load_object
+    #   before_action :ensure_object_is_active
     def ensure_object_is_active
       unless @obj.active?
         @valid_from = @obj.valid_from
         @valid_until = @obj.valid_until
         @obj = nil
         render_obj_error(410, "gone")
-        return false
       end
       return true
     end
@@ -37,13 +36,12 @@ module RailsConnector
     # not, a 403 Forbidden error message will be generated (by calling render_obj_error)
     #
     # To require the check for all actions, use this in your controllers:
-    #   before_filter :load_object
-    #   before_filter :ensure_object_is_permitted
+    #   before_action :load_object
+    #   before_action :ensure_object_is_permitted
     def ensure_object_is_permitted
       unless is_permitted(@obj)
         @obj = nil
         render_obj_error(403, "forbidden")
-        return false
       end
       return true
     end
@@ -59,7 +57,7 @@ module RailsConnector
         :template => "errors/#{status}_#{name}",
         :layout => false,
         :status => status,
-        :content_type => Mime::HTML
+        :content_type => Mime[:html]
       )
     end
 

data/lib/rails_connector/cms_dispatch_controller.rb

@@ -2,17 +2,17 @@ module RailsConnector
 
   class CmsDispatchController < ActionController::Metal
     def process(action)
-      CmsEnv.new(env).load
-      controller = target_controller(env)
-      env["action_dispatch.request.path_parameters"][:controller] = controller.controller_path
+      CmsEnv.new(request.env).load
+      controller = target_controller(request.env)
+      request.env["action_dispatch.request.path_parameters"][:controller] = controller.controller_path
 
       if !obj_not_found? && action == 'index'
         action = loaded_obj.controller_action_name
       end
 
-      env["action_dispatch.request.path_parameters"][:action] = action
+      request.env["action_dispatch.request.path_parameters"][:action] = action
 
-      self.response = controller.action(action).call(env)
+      self.response = controller.action(action).call(request.env)
     end
 
     private
@@ -31,7 +31,7 @@ module RailsConnector
     end
 
     def loaded_obj
-      env[CmsEnv::OBJ_ENV_KEY]
+      request.env[CmsEnv::OBJ_ENV_KEY]
     end
 
     def obj_not_found?

data/lib/rails_connector/cms_test_request.rb

@@ -3,21 +3,6 @@ module RailsConnector
     def for_cms_object(test_obj=nil)
       # prepare the env as if the given obj was loaded by CmsEnv
       env[RailsConnector::CmsEnv::OBJ_ENV_KEY] = test_obj if test_obj
-      class << self
-        # This special behaviour is necessary for testing controllers that descend from DefaultCmsController.
-        # These controllers do not have explicit routes by default.
-        # Instead, they are reached via the CmsDispatchController.
-        # The TestRequest must therefore use CmsDispatchController as a fallback route.
-        def assign_parameters(routes, controller_path, action, parameters = {})
-          super(routes, controller_path, action, parameters)
-        rescue ActionController::UrlGenerationError, ActionController::RoutingError, AbstractController::ActionNotFound => e
-          begin
-            super(routes, "rails_connector/cms_dispatch", action, parameters)
-          rescue ActionController::RoutingError, AbstractController::ActionNotFound
-            raise e
-          end
-        end
-      end
     end
   end
 end

data/lib/rails_connector/configuration.rb

@@ -77,6 +77,8 @@ module RailsConnector
       end
 
       def to_prepare
+        BasicObj.reset_reflections
+
         unless Rails.configuration.cache_classes
           after_initialize
           NamedLink.reset_cache

data/lib/rails_connector/content.rb

@@ -0,0 +1,11 @@
+module RailsConnector
+
+  # This class allows us to read out the editor of an Obj,
+  # if it has edited content
+  class Content < CmsBaseModel
+
+    self.primary_key = :content_id
+
+  end
+
+end

data/lib/rails_connector/date_attribute.rb

@@ -25,4 +25,4 @@ module RailsConnector
     end
   end
 
-end
+end

data/lib/rails_connector/engine.rb

@@ -1,6 +1,6 @@
-require "rails"
-require "active_record/railtie"
-require "action_view"
+require 'rails'
+require 'active_record/railtie'
+require 'action_view'
 
 require 'jquery-rails'
 
@@ -14,6 +14,10 @@ module ::RailsConnector
     # make sure our exceptions cause an adequate error page and http status code
     config.action_dispatch.rescue_responses.merge!("RailsConnector::ResourceNotFound" => :not_found)
 
+    initializer 'rails_connector.add_fiona_time_type' do
+      ActiveRecord::Type.register(:fiona_datetime, ::FionaDateTime)
+    end
+
     initializer "rails_connector.add_cms_routing_paths", :after => :add_routing_paths do |app|
       cms_route = File.expand_path("cms_routes.rb", paths['config'].to_a.first)
       app.routes_reloader.paths.push(cms_route)
@@ -55,10 +59,10 @@ module ::RailsConnector
       ActionView::Base.__send__(:include, CmsRoutingHelper)
     end
 
+
     config.autoload_paths += paths['lib'].to_a
     config.autoload_once_paths += paths['lib'].to_a
 
     RailsConnector.rack_middlewares.each { |middleware| config.app_middleware.use middleware }
   end
 end
-

data/lib/rails_connector/fiona_datetime.rb

@@ -0,0 +1,14 @@
+require 'active_record/type'
+class FionaDateTime < ActiveRecord::Type::Time
+  def type
+    :fiona_datetime
+  end
+
+  def serialize(value)
+    value.to_iso if value
+  end
+
+  def deserialize(value)
+    Time.from_iso(value).in_time_zone if value
+  end
+end

data/lib/rails_connector/job.rb

@@ -0,0 +1,13 @@
+module RailsConnector
+
+  # This class allows us to read out basic information about jobs
+  class Job < CmsBaseModel
+
+    self.primary_key = "job_id"
+
+    def self.table_name
+      "#{table_name_prefix}" "jobs"
+    end
+  end
+
+end

data/lib/rails_connector/meta.rb

@@ -0,0 +1,148 @@
+module RailsConnector
+
+  module Meta
+
+    # This method is an equivalent of Rails.logger.silence, which has been deprecated
+    def self.hello_im_rails_and_im_retarted_so_please_be_patient(&block)
+      begin
+        old_logger_level, Rails.logger.level = Rails.logger.level, Logger::ERROR
+        yield self
+      ensure
+        Rails.logger.level = old_logger_level
+      end
+    end
+
+    def self.included(base) #:nodoc:
+      #  Class enhancements
+      base.extend(ClassMethods)
+    end
+
+    # The RailsConnector::ObjClass object for this file format.
+    # This will always return a proper object, even if no custom
+    # Ruby class exists.
+    def obj_class_definition
+      @obj_class_definition ||= RailsConnector::Meta::EagerLoader.instance.obj_class(self.obj_class)
+    end
+    alias_method :obj_class_def, :obj_class_definition
+
+    # Returns true, if there is a custom Ruby class defined for the object
+    # or false, if it is represented by RailsConnector::Obj
+    def has_custom_ruby_class?
+      self.class.is_custom_ruby_class?
+    end
+
+    # Returns the custom attributes in the form of a Hash.
+    def custom_attributes
+      self.obj_class_definition.custom_attributes
+    end
+
+    # Returns true, if the file format has an attribute of the given name.
+    def custom_attribute?(attr)
+      self.obj_class_definition.custom_attribute?(attr)
+    end
+
+    # Returns an Array of String of all mandatory attributes, no mather if it's
+    # custom or built-in. Built-in attributes are underscored (valid_from,
+    # not validFrom).
+    # Possible +options+ are:
+    # <tt>:only_custom_attributes</tt>:: Return only custom attributes, omit
+    # built-in attributes like content_type or valid_from.
+    def mandatory_attribute_names(options = {})
+      self.obj_class_definition.mandatory_attribute_names(options)
+    end
+
+    # Returns true, if the file format has an mandatory attribute of the given name.
+    def mandatory_attribute?(attr)
+      self.obj_class_definition.mandatory_attribute?(attr)
+    end
+
+    # Returns the version of this object. This number is increased every time
+    # this object is released.
+    def version
+      load_meta_details
+      @object_with_meta_data.version.presence.to_i || 0
+    end
+
+    # Returns the time of the reminder, if it is set.
+    def reminder_from
+      load_meta_details
+      @object_with_meta_data.reminder_from.presence &&
+          ::ActiveModel::Type::DateTime.new.deserialize(@object_with_meta_data.reminder_from)
+    end
+
+    # Returns the reminder comment, if a reminder is set.
+    def reminder_comment
+      load_meta_details
+      @object_with_meta_data.reminder_comment
+    end
+
+    # Return the name of the workflow, that is assigned to this object.
+    def workflow_name
+      load_meta_details
+      @object_with_meta_data.workflow_name
+    end
+
+    # Return the current editor as a String. If there is no edited content,
+    # which is always the case in live mode, an empty String is returned.
+    # The 'contents' table is queried for this information.
+    def editor
+      return @editor if @editor
+
+      load_meta_details
+
+      content_id = if self.edited?
+        @object_with_meta_data.edited_content_id
+      else
+        @object_with_meta_data.released_cont_id
+      end
+
+      if content_id
+        content = RailsConnector::Content.find(content_id)
+        @editor = content.editor
+      else
+        @editor = ''
+      end
+    end
+
+    def committed?
+      load_meta_details
+      !@object_with_meta_data.committed_cont_id.nil?
+    end
+
+    private
+
+    # Load the objects details from the `objects' tables.
+    def load_meta_details #:nodoc:
+      return if @object_with_meta_data
+
+      @object_with_meta_data = RailsConnector::ObjectWithMetaData.find(self.id)
+
+      # reset depending instance variables
+      @editor = nil
+    end
+
+
+    # the methods in this module will become class methods
+    module ClassMethods
+
+      # The RailsConnector::ObjClass object for this file format.
+      # This will only return a proper object if a custom Ruby class exists
+      # and will throw a RuntimeError otherwise.
+      def obj_class_definition
+        raise "Obtaining the obj_class_definition of an Obj without custom Ruby class " \
+                  "is logically impossible." unless is_custom_ruby_class?
+        @obj_class_definition ||= RailsConnector::Meta::EagerLoader.instance.obj_class(self.name)
+      end
+      alias_method :obj_class_def, :obj_class_definition
+
+      # RailsConnector::AbstractObj returns false, everything else true.
+      # TODO: RailsConnector::AbstractObj does not exist here
+      def is_custom_ruby_class?
+        self != RailsConnector::BasicObj
+      end
+
+    end
+
+  end
+
+end

data/lib/rails_connector/meta/eager_loader.rb

@@ -0,0 +1,82 @@
+# -*- encoding : utf-8 -*-
+require 'singleton'
+require 'set'
+
+module RailsConnector
+  module Meta
+    class EagerLoader
+      include Singleton
+      attr_reader :obj_classes
+
+      def initialize
+        # Rails.logger.debug "EagerLoader: I am eager to start working"
+        @obj_classes = {}
+        RailsConnector::ObjClass.includes(:custom_attributes_raw).all.each do |obj_class|
+          @obj_classes[obj_class.name] = obj_class if obj_class
+        end
+        preload_attribute_blobs
+      end
+
+      def obj_class(name)
+        name = name.to_s
+        if !@obj_classes.fetch(name, nil).nil?
+          @obj_classes[name]
+        else
+          # TODO: preload_attribute_blobs for obj_class
+          @obj_classes[name] ||= RailsConnector::ObjClass.find_by_obj_class_name(name)
+        end
+      end
+
+      def forget_obj_class(name)
+        @obj_classes.delete(name.to_s)
+      end
+
+      protected
+      def preload_attribute_blobs
+        attribute_names = Set.new
+        @obj_classes.each do |_, obj_class|
+          obj_class.custom_attributes.each do |attribute_name, _|
+            attribute_names << attribute_name
+          end
+        end
+
+        blob_names = attribute_names.map {|attribute_name| "#{attribute_name}.jsonAttributeDict" }
+        # Fiona >= 6.8
+        if RailsConnector::BlobMapping.exists?
+          blob_names               = attribute_names.map {|attribute_name| "#{attribute_name}.jsonAttributeDict" }
+          fingerprint_map          = RailsConnector::BlobMapping.get_fingerprint_map(blob_names)
+          blob_fingerprints        = fingerprint_map.values
+          # NOTE: this is correct!
+          blobs                    = RailsConnector::Blob.where(:blob_name => blob_fingerprints).to_a
+          blob_map                 = Hash[blobs.map {|b| [b.blob_name, b]}]
+
+          @obj_classes.each do |_, obj_class|
+            obj_class.custom_attributes.each do |_, attribute|
+              blob_name   = "#{attribute.name}.jsonAttributeDict"
+              fingerprint = fingerprint_map[blob_name]
+              blob        = blob_map[fingerprint]
+
+              next unless blob && blob.blob_data?
+              attribute.instance_variable_set(:@blob_data, ::JSON.parse(blob.blob_data))
+            end
+          end
+        # Fiona = 6.7
+        else
+          blob_names               = attribute_names.map {|attribute_name| "#{attribute_name}.jsonAttributeDict" }
+          blobs                    = RailsConnector::Blob.where(:blob_name => blob_names).to_a
+          blob_map                 = Hash[blobs.map {|b| [b.blob_name, b]}]
+
+          @obj_classes.each do |_, obj_class|
+            obj_class.custom_attributes.each do |_, attribute|
+              blob_name   = "#{attribute.name}.jsonAttributeDict"
+              blob        = blob_map[blob_name]
+
+              next unless blob && blob.blob_data?
+              attribute.instance_variable_set(:@blob_data, ::JSON.parse(blob.blob_data))
+            end
+          end
+        end
+      end
+    end
+  end
+end