infopark_fiona_connector 7.0.1.5.2.3.rc7

data/lib/rails_connector/blob.rb

@@ -0,0 +1,75 @@
+module RailsConnector
+  # A binary containing the blob data of a Content or CMS management
+  # data of Attribute (fields), ObjClass (object classes), for example.
+  class Blob < CmsBaseModel
+    self.primary_key = "blob_name"
+
+    class << self
+      # Does not retrieve the column blob_data.
+      def find_with_excluded_blob_data(primary_key)
+        select(:blob_name, :blob_length).find(primary_key)
+      end
+
+      alias_method :find_without_excluded_blob_data, :find
+      alias_method :find, :find_with_excluded_blob_data
+    end
+
+    def length
+      blob_length
+    end
+
+    def data
+      @data ||= self.class.find_without_excluded_blob_data(id).blob_data
+    end
+
+    def path_of_stored_data(use_cached_file_if_older_than = Time.now)
+      store_data if !File.exist?(path) || file_size_differs? || stale?(use_cached_file_if_older_than)
+      path
+    end
+
+    def self.cache_dir
+      Configuration.blob_cache_dir || File.join(Rails.root, %w(tmp cache))
+    end
+
+    def self.initialize_blob_streaming_for(adapter_name)
+      # Redefines store_data:
+      case adapter_name
+      when /mysql$/i
+        raise "Adapter 'mysql' no longer supported. " +
+              "Please change adapter in your database.yml to 'mysql2'."
+      when /mysql2/i
+        require "rails_connector/blob_mysql"
+        include BlobMysql
+      when /oracle/i
+        require "rails_connector/blob_oracle"
+        include BlobOracle
+      end
+    end
+
+    private
+
+    def path
+      "#{Blob.cache_dir}/#{id}"
+    end
+
+    def store_data
+      store_data_atomically do |f|
+        f << data
+      end
+    end
+
+    def store_data_atomically(&block)
+      tmp_file = "#{path}.#{Process.pid}"
+      File.open(tmp_file, "wb", &block)
+      File.rename(tmp_file, path)
+    end
+
+    def stale?(time)
+      time > File.mtime(path)
+    end
+
+    def file_size_differs?
+      blob_length != File.stat(path).size
+    end
+  end
+end

data/lib/rails_connector/blob_mapping.rb

@@ -0,0 +1,15 @@
+module RailsConnector
+  class BlobMapping < CmsBaseModel
+    def self.exists?
+      table_exists?
+    end
+
+    def self.get_fingerprint(name)
+      find_by_blob_name(name).fingerprint
+    end
+
+    def self.get_fingerprint_map(blob_names)
+      Hash[where(blob_name: blob_names).select(%i(blob_name fingerprint)).map { |b| [b.blob_name, b.fingerprint] }]
+    end
+  end
+end

data/lib/rails_connector/blob_mysql.rb

@@ -0,0 +1,30 @@
+require "mysql2"
+require "mysql_blob_streaming"
+
+module RailsConnector
+  module BlobMysql
+    def self.included(base)
+      base.instance_eval do
+        define_method :store_data do
+          store_data_atomically { |f| fetch_into_file(f) }
+        end
+      end
+    end
+
+    def fetch_into_file(file)
+      mysql2_client = self.class.connection.raw_connection
+      ActiveRecord::Base.logger.debug "Streaming blob from MySQL2 into #{file.path}"
+
+      table_name = mysql2_client.escape(self.class.table_name)
+      primary_key = mysql2_client.escape(self.class.primary_key)
+      escaped_id = mysql2_client.escape(id)
+      query = "SELECT `blob_data` FROM `#{table_name}` WHERE `#{primary_key}`='#{escaped_id}'"
+
+      MysqlBlobStreaming.stream(mysql2_client, query, 1.megabyte) do |chunk|
+        file << chunk
+        chunk = nil
+        GC.start
+      end
+    end
+  end
+end

data/lib/rails_connector/blob_oracle.rb

@@ -0,0 +1,37 @@
+module RailsConnector
+  module BlobOracle
+    def self.included(base)
+      base.instance_eval do
+        define_method :store_data do
+          store_data_atomically { |f| fetch_into_file(f) }
+        end
+      end
+    end
+
+    def fetch_into_file(file)
+      blob = blob_handle
+      while data = blob.read(buff_size ||= 1.megabyte)
+        file <<  data
+        data = nil
+        GC.start
+      end
+    ensure
+      blob&.close
+    end
+
+    private
+
+    def sql
+      %(
+        SELECT blob_data
+        FROM #{self.class.table_name}
+        WHERE #{self.class.primary_key} = :1
+      )
+    end
+
+    def blob_handle
+      con = self.class.connection.raw_connection
+      con.exec(sql, id).fetch.first
+    end
+  end
+end

data/lib/rails_connector/cache_middleware.rb

@@ -0,0 +1,13 @@
+module RailsConnector
+  class CacheMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      CmsBaseModel.cache do
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rails_connector/channel.rb

@@ -0,0 +1,18 @@
+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,
+             -> { 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

@@ -0,0 +1,111 @@
+module RailsConnector
+  # @api public
+  module CmsAccessible
+    protected
+
+    # Filter method to load a CMS object.
+    #
+    # To require the loading for all actions, use this in your controllers:
+    #   before_action :load_object
+    def load_object
+      CmsEnv.new(request.env).load
+      loaded_obj = request.env[CmsEnv::OBJ_ENV_KEY]
+      raise loaded_obj if loaded_obj.is_a?(StandardError)
+
+      @obj = loaded_obj
+    end
+
+    # Filter method to check if the already loaded object is active. If it is
+    # 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_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")
+      end
+      true
+    end
+
+    # Filter method to check if access to the loaded object is permitted. If it is
+    # 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_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")
+      end
+      true
+    end
+
+    # This method is called when rendering an error caused by either {ensure_object_is_permitted}
+    # or {ensure_object_is_active} before filter. It renders an error template located in
+    # "errors/*.html.erb" with given HTTP status and content type "text/html" and with no layout.
+    # Overwrite this method to change the error page.
+    # @api public
+    def render_obj_error(status, name)
+      force_html_format
+      render(
+        template: "errors/#{status}_#{name}",
+        layout: false,
+        status: status,
+        content_type: Mime[:html]
+      )
+    end
+
+    # Enforce "html" as template format.
+    # @api public
+    def force_html_format
+      request.format = :html
+    end
+
+    # Inclusion hook to make is_permitted available as helper method.
+    def self.included(base)
+      base.__send__ :helper_method, :is_permitted
+    end
+
+    # Helper method to check live permissions
+    def is_permitted(obj)
+      obj.permitted_for_user?(current_user)
+    end
+
+    # Filter method which sets the header 'X-Robots-Tag: unavailable_after'
+    # to the valid_until date of the current object.
+    def set_google_expire_header
+      if @obj && (date = @obj.valid_until)
+        headers["X-Robots-Tag: unavailable_after"] = date.rfc822
+      end
+    end
+
+    # Deliver the obj's body as response by file or data.
+    # May respond with status 304 if a If-Modified-Since header is found.
+    # @api public
+    def deliver_file
+      if @obj.body_data_url
+        redirect_to enforce_protocol_from_request(@obj.body_data_url)
+      elsif stale?(last_modified: @obj.last_changed.utc)
+        mime_type = @obj.mime_type
+        mime_type += "; charset=utf-8" if %r{^text/}.match?(mime_type)
+
+        if (filepath = @obj.body_data_path).present?
+          send_file(File.expand_path(filepath), {
+                      type: mime_type,
+                      filename: @obj.filename,
+                      disposition: "inline"
+                    })
+        else
+          # generics should send its body, empty files should be delivered as
+          # empty files - and not lead to an application error
+          send_data @obj.body || "", type: mime_type, filename: @obj.filename, disposition: "inline"
+        end
+      end
+    end
+  end
+end

data/lib/rails_connector/cms_base_model.rb

@@ -0,0 +1,62 @@
+module RailsConnector
+  # This is the abstract class from which all CMS models derive.
+  # The database connection is set to "infopark_rails_connector_${RAILS_ENV}" and the table prefix is
+  # determined from the instance_name.
+  #
+  # [instance_name] the name of the CMS instance
+  class CmsBaseModel < ActiveRecord::Base
+    @@instance_name = "default"
+    cattr_accessor :instance_name
+    self.abstract_class = true
+
+    def self.configure_database(db_connection_spec)
+      establish_connection(db_connection_spec)
+      Blob.initialize_blob_streaming_for(connection.adapter_name)
+    end
+
+    # Returns :table_name_with_underscore. All CMS models use this kind of primary key naming.
+    def self.primary_key_prefix_type
+      :table_name_with_underscore
+    end
+
+    # CmsBaseModel and all of its descendants are model classes that can access CMS contents.
+    def self.cms_model?
+      true
+    end
+
+    # FIXME: Find a more stable solution for this
+    #
+    # Since ActiveRecord 4.2 finding Objs by name is no longer consistent when
+    # switching between edited and released content at runtime. As long as we
+    # find a better solution this mitigates the behaviour.
+    def self.find_by(arg, *args)
+      where(arg, *args).take
+    end
+
+    def readonly?
+      true
+    end
+
+    def attribute_for_inspect(attr_name)
+      value = read_attribute(attr_name)
+
+      if value.is_a?(RailsConnector::LinkList)
+        value.destination_objects.map(&:to_s)
+      else
+        super
+      end
+    end
+
+    class << self
+      # The prefix of the table name is determined by using the instance name followed by an underscore.
+      # Set the instance_name in your environment to the CMS instance name (defaults to 'default').
+      #
+      #   CmsBaseModel.instance_name = 'default'
+      #
+      # ActiveRecord::Base::primary_key_prefix_type has no effect here.
+      def table_name_prefix
+        @@instance_name.blank? ? "" : (@@instance_name + "_")
+      end
+    end
+  end
+end

data/lib/rails_connector/cms_dispatch_controller.rb

@@ -0,0 +1,43 @@
+module RailsConnector
+  class CmsDispatchController < ActionController::Metal
+    def process(action)
+      CmsEnv.new(request.env).load
+      controller = target_controller(request.env)
+      request.env["action_dispatch.request.path_parameters"][:controller] = controller.controller_path
+
+      action = loaded_obj.controller_action_name if !obj_not_found? && action == "index"
+
+      request.env["action_dispatch.request.path_parameters"][:action] = action
+
+      self.response = controller.action(action).call(request.env)
+    end
+
+    private
+
+    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
+      else
+        default_controller
+      end
+    rescue NameError
+      default_controller
+    end
+
+    def loaded_obj
+      request.env[CmsEnv::OBJ_ENV_KEY]
+    end
+
+    def obj_not_found?
+      loaded_obj.is_a?(StandardError)
+    end
+
+    def default_controller
+      CmsController
+    end
+  end
+end

data/lib/rails_connector/cms_env.rb

@@ -0,0 +1,65 @@
+module RailsConnector
+  class CmsEnv
+    OBJ_ENV_KEY = "INFOPARK_OBJ".freeze
+
+    def initialize(env)
+      @env = env
+    end
+
+    def load
+      return if env[OBJ_ENV_KEY]
+
+      load_object
+    end
+
+    protected
+
+    attr_reader :env
+
+    def load_object
+      env[OBJ_ENV_KEY] =
+        begin
+          find_obj
+        rescue StandardError => e
+          e
+        end
+    end
+
+    def find_obj
+      found_obj =
+        if params[:id]
+          Obj.find(params[:id])
+        elsif params[:permalink].present?
+          self.class.find_permalink_by_param(params[:permalink])
+        else
+          if callback = RailsConnector::Configuration.choose_homepage_callback
+            callback_result = callback.call(env)
+            if callback_result.is_a?(Obj)
+              callback_result
+            else
+              raise "choose_homepage callback did not return an Obj. "\
+                "Instead saw #{callback_result.class}."
+            end
+          else
+            Obj.homepage
+          end
+        end
+
+      if found_obj.suppressed?
+        raise RailsConnector::ResourceNotFound,
+              "Tried to access Obj #{found_obj.inspect}, but it is suppressed (suppress_export is set)!"
+      end
+
+      found_obj
+    end
+
+    def params
+      env["action_dispatch.request.path_parameters"]
+    end
+
+    def self.find_permalink_by_param(permalink_param)
+      permalink = Array(permalink_param).join("/")
+      Obj.find_by_permalink!(permalink)
+    end
+  end
+end