infopark_cloud_connector 7.0.2 → 7.1.0

data/lib/rails_connector/blob.rb

@@ -37,7 +37,7 @@ class Blob
   private
 
   def raw_data
-    @raw_data ||= CmsBackend.find_blob_data_by_id(id)
+    @raw_data ||= CmsBackend.instance.find_blob_data_by_id(id)
   end
 
   def meta_data

data/lib/rails_connector/cache_middleware.rb

@@ -6,10 +6,10 @@ class CacheMiddleware
   end
 
   def call(env)
-    CmsBackend.begin_caching
+    CmsBackend.instance.begin_caching
     @app.call(env)
   ensure
-    CmsBackend.end_caching
+    CmsBackend.instance.end_caching
   end
 end
 

data/lib/rails_connector/cms_backend.rb

@@ -55,9 +55,6 @@ module RailsConnector
       def instance
         @instance ||= new
       end
-
-      delegate :begin_caching, :end_caching, :caching?, :query_counter, :find_workspace_data_by_id,
-          :find_obj_data_by, :find_blob_data_by_id, to: :instance
     end
 
     def initialize
@@ -91,7 +88,7 @@ module RailsConnector
       raw_data = if id == 'published' && workspace_data_from_cache
         begin
           ContentService.query('workspaces/query', request_params, timeout: 1)
-        rescue BackendNotAvailable => e
+        rescue CommunicationError => e
           warn_backend_not_available(id, from_content_state_id, e.message)
           return workspace_data_from_cache
         end
@@ -106,15 +103,12 @@ module RailsConnector
       end
     end
 
-    def find_obj_data_by(workspace_data, index, keys)
-      index = index.to_s
-      assert_valid_index_name(index)
-      raw_data = find_raw_data_from_cache_or_database_by(workspace_data, index, keys)
-      raw_data.map do |raw_list|
-        raw_list.map do |raw_obj_data|
-          ObjDataFromService.new(raw_obj_data)
-        end
-      end
+    def find_obj_data_by(revision, index, keys)
+      find_obj_data_filtering_deleted_by(revision, index, keys, false)
+    end
+
+    def find_obj_data_including_deleted_by(revision, index, keys)
+      find_obj_data_filtering_deleted_by(revision, index, keys, true)
     end
 
     def find_blob_data_by_id(id)
@@ -132,20 +126,33 @@ module RailsConnector
 
     private
 
-    def find_raw_data_from_cache_or_database_by(workspace_data, index, keys)
+    def find_obj_data_filtering_deleted_by(revision, index, keys, include_deleted)
+      index = index.to_s
+      assert_valid_index_name(index)
+      raw_data = find_raw_data_from_cache_or_database_by(revision, index, keys)
+
+      raw_data.map do |raw_result|
+        raw_result.each_with_object([]) do |raw_data, result|
+          next if raw_data['_modification'] == ['deleted'] && !include_deleted
+          result << ObjDataFromService.new(raw_data)
+        end
+      end
+    end
+
+    def find_raw_data_from_cache_or_database_by(revision, index, keys)
       keys_from_database = []
       # load results from cache
       results_from_cache = keys.map do |key|
-        find_raw_data_from_cache_by(workspace_data, index, key).tap do |objs|
+        find_raw_data_from_cache_by(revision, index, key).tap do |objs|
           keys_from_database << key unless objs
         end
       end
 
       # load cache misses from database and store them in cache
       results_from_database =
-          find_raw_data_from_database_by(workspace_data, index, keys_from_database)
+          find_raw_data_from_database_by(revision, index, keys_from_database)
       keys_from_database.each_with_index do |key, key_number|
-        store_raw_data_list_in_cache(workspace_data, index, key, results_from_database[key_number])
+        store_raw_data_list_in_cache(revision, index, key, results_from_database[key_number])
       end
 
       # combine the results
@@ -154,11 +161,11 @@ module RailsConnector
       end
     end
 
-    def find_raw_data_from_cache_by(workspace_data, index, key)
-      ContentStateCaching.find_obj_data(workspace_data.content_state, index, key) if caching?
+    def find_raw_data_from_cache_by(revision, index, key)
+      ContentStateCaching.find_obj_data(revision.content_state, index, key) if caching?
     end
 
-    def find_raw_data_from_database_by(workspace_data, index, keys)
+    def find_raw_data_from_database_by(revision, index, keys)
       return [] if keys.blank?
       instrumenter = ActiveSupport::Notifications.instrumenter
       instrumenter.instrument(
@@ -166,36 +173,47 @@ module RailsConnector
       ) do
         @query_counter += 1
         queries = ContentServiceObjQueries.new(keys.map {|key| {:type => index, :param => key} })
-        until queries.finished?
-          queries.handle_response(ContentService.query(
-            "objs/query",
-            :queries => queries.open_queries,
-            :workspace_id => workspace_data.id,
-            :revision_id => workspace_data.revision_id
-          ))
-        end
+        queries.handle_response(request_content_service(queries, revision)) until queries.finished?
         queries.results
       end
     end
 
+    def request_content_service(queries, revision)
+      ContentService.query('objs/query', content_service_request_params(queries, revision))
+    end
+
+    def content_service_request_params(queries, revision)
+      params = {
+        queries: queries.open_queries,
+        revision_id: revision.id,
+        include_deleted: true
+      }
+
+      # Not every revision has a workspace,
+      # e.g. when requesting with the base revision of the current workspace.
+      params[:workspace_id] = revision.workspace.id if revision.workspace
+
+      params
+    end
+
     UNIQUE_INDICES = [:id, :path, :permalink].freeze
 
-    def store_raw_data_list_in_cache(workspace_data, index, key, raw_data_list)
+    def store_raw_data_list_in_cache(revision, index, key, raw_data_list)
       raw_data_list.each do |values|
         UNIQUE_INDICES.each do |unique_index|
           unique_index_values = values["_#{unique_index}"]
           if unique_index_values.present?
-            store_item_in_cache(workspace_data, unique_index, unique_index_values.first, [values])
+            store_item_in_cache(revision, unique_index, unique_index_values.first, [values])
           end
         end
       end
       unless UNIQUE_INDICES.include?(index)
-        store_item_in_cache(workspace_data, index, key, raw_data_list)
+        store_item_in_cache(revision, index, key, raw_data_list)
       end
     end
 
-    def store_item_in_cache(workspace_data, index, key, item)
-      ContentStateCaching.store_obj_data(workspace_data.content_state, index, key, item)
+    def store_item_in_cache(revision, index, key, item)
+      ContentStateCaching.store_obj_data(revision.content_state, index, key, item)
     end
 
     def find_blob_data_from_database_by(id)

data/lib/rails_connector/cms_rest_api.rb

@@ -90,8 +90,6 @@ module RailsConnector
       private
 
       def request_cms_api(action, resource_path, payload, options)
-        reset_connection_manager if connection_manager.uri != uri
-
         decoded = response_for_request_cms_api(action, resource_path, payload)
         return decoded unless Hash === decoded
         return decoded unless decoded.keys == ["task"]
@@ -102,6 +100,8 @@ module RailsConnector
       end
 
       def response_for_request_cms_api(method, resource_path, payload = nil)
+        reset_connection_manager if connection_manager.uri != uri
+
         request = method_to_net_http_class(method).new(path(resource_path))
         set_headers(request)
         request.body = MultiJson.encode(payload) if payload.present?
@@ -111,19 +111,24 @@ module RailsConnector
 
       def handle_response(response)
         code = response.code.to_i
-        if code.to_s.start_with?('2')
+        if response.code.start_with?('2')
           MultiJson.load(response.body)
         elsif response.code == '403'
           raise AccessDenied.new(response.body)
-        elsif (400...500).include?(code)
+        else
           begin
             specific_output = MultiJson.decode(response.body)['error']
-            raise ClientError.new(specific_output, code)
+
+            if response.code.start_with?('4')
+              raise ClientError.new(specific_output, code)
+            elsif response.code == '500' && specific_output
+              raise BackendError.new(specific_output, code)
+            else # 3xx and >500 are treated as NetworkErrors
+              raise NetworkError.new(response.body, code)
+            end
           rescue MultiJson::DecodeError
-            raise BackendNotAvailable.new(response.body, code)
+            raise NetworkError.new(response.body, code)
           end
-        else
-          raise BackendNotAvailable.new(response.body, code)
         end
       end
 

data/lib/rails_connector/cms_rest_api/attribute_serializer.rb

@@ -0,0 +1,62 @@
+module RailsConnector
+  class CmsRestApi
+    module AttributeSerializer
+      class << self
+        def convert(attributes)
+          Hash[
+            attributes.map do |attribute_name, value|
+              converted_value = if link_array?(value)
+                convert_links(value)
+              elsif value.is_a?(BasicObj)
+                value.id
+              elsif obj_array?(value)
+                value.map(&:id)
+              elsif value.is_a?(Time) || value.is_a?(Date)
+                convert_time(value)
+              elsif value.is_a?(Array)
+                value.map(&:to_s)
+              elsif value.is_a?(File)
+                RailsConnector::CmsRestApi::BlobUploader.upload_file(value)
+              else
+                value.to_s
+              end
+
+              [attribute_name.to_s, converted_value]
+            end
+          ]
+        end
+
+        private
+
+        def link_array?(value)
+          value.is_a?(Array) && value.all? do |element|
+            element.is_a?(Link)
+          end
+        end
+
+        def obj_array?(value)
+          value.is_a?(Array) && value.all? do |element|
+            element.is_a?(BasicObj)
+          end
+        end
+
+        def convert_links(links)
+          links.map do |link|
+            link.to_cms_api_linklist_params
+          end
+        end
+
+        def convert_time(point_in_time)
+          time_object = if point_in_time.instance_of?(Date)
+            point_in_time.to_time
+          else
+            point_in_time.to_time.utc
+          end
+
+          time_object.strftime("%Y%m%d%H%M%S")
+        end
+
+      end
+    end
+  end
+end

data/lib/rails_connector/cms_rest_api/blob_uploader.rb

@@ -0,0 +1,18 @@
+module RailsConnector
+  class CmsRestApi
+    module BlobUploader
+      class << self
+        def upload_file(file)
+          upload_permission = CmsRestApi.get('blobs/upload_permission')
+
+          fields = upload_permission['fields'].to_a + [[:file, file]]
+
+          # Net/HTTP does not support multipart forms
+          RestClient.post(upload_permission['url'], fields)
+
+          upload_permission['blob']
+        end
+      end
+    end
+  end
+end

data/lib/rails_connector/communication_error.rb

@@ -0,0 +1,17 @@
+module RailsConnector
+
+  class CommunicationError < StandardError
+    attr_reader :http_code, :message
+
+    def initialize(message, http_code)
+      @http_code = http_code.to_i
+      @message = message
+    end
+
+    def to_s
+      "HTTP-Response-Code: #{self.http_code}, Body: \"#{self.message}\""
+    end
+
+  end
+
+end

data/lib/rails_connector/configuration.rb

@@ -170,6 +170,30 @@ module RailsConnector
               ' config.action_dispatch.x_sendfile_header = "X-Sendfile"'
       end
 
+      def obj_formats
+        @obj_formats ||= {
+          '_changes_list' => proc do |obj|
+            {
+              id: obj.id,
+              modification: obj.modification,
+              deleted: obj.modification == 'deleted',
+              obj_class: obj.obj_class,
+              binary: obj.binary?,
+              title: obj.description_for_editor,
+              last_changed: obj.last_changed.strftime('%d.%m.%Y - %H:%M')
+            }
+          end
+        }
+      end
+
+      def register_obj_format(name, &block)
+        if name.start_with? '_'
+          raise InvalidFormatNameError.new('Format names starting with underscore are not allowed.')
+        else
+          obj_formats[name] = block
+        end
+      end
+
       private
 
       def content_service
@@ -188,4 +212,8 @@ module RailsConnector
 
   class ConfigurationError < StandardError
   end
+
+  class InvalidFormatNameError < StandardError; end
+
 end
+

data/lib/rails_connector/connection_manager.rb

@@ -62,7 +62,7 @@ module RailsConnector
       begin
         yield
       rescue *SOCKET_ERRORS => e
-        raise BackendNotAvailable.from_socket_error(e) if retried
+        raise NetworkError.from_socket_error(e) if retried
         ensure_finished
         retried = true
         retry
@@ -74,7 +74,7 @@ module RailsConnector
       begin
         yield
       rescue *SOCKET_ERRORS => e
-        raise BackendNotAvailable.from_socket_error(e) if attempt == 2
+        raise NetworkError.from_socket_error(e) if attempt == 2
         attempt += 1
         retry
       end

data/lib/rails_connector/content_conversion.rb

@@ -1,5 +1,4 @@
 require 'nokogiri'
-require 'addressable/uri'
 
 module RailsConnector
 
@@ -8,13 +7,17 @@ module RailsConnector
       doc = Nokogiri::HTML.parse("<div class='internal_jump_point'>#{input}</div>")
 
       doc.css('body a').each do |a_tag|
-        item = a_tag.attributes['href']
-        item.value = convert_link(item.value, request_host, request_port)
+        if href = a_tag.attributes['href']
+          link = Link.parse(href.value, request_host, request_port)
+          href.value = link.to_cms_api_html_url
+        end
       end
 
       doc.css('body img').each do |img_tag|
-        item = img_tag.attributes['src']
-        item.value = convert_link(item.value, request_host, request_port)
+        if src = img_tag.attributes['src']
+          link = Link.parse(src.value, request_host, request_port)
+          src.value = link.to_cms_api_html_url
+        end
       end
 
       new_html = doc.css('body div.internal_jump_point').inner_html
@@ -23,65 +26,16 @@ module RailsConnector
       new_html.gsub(nbsp, "&nbsp;")
     end
 
-    private
-
-    def self.convert_link(target, request_host, request_port)
-      if target.present?
-        uri = Addressable::URI.parse(target)
-
-        if uri.absolute?
-          if internal_url?(uri, request_host, request_port)
-            target = convert_single_link(uri)
-          end
-        else
-          if uri.path.present?
-            target = convert_single_link(uri)
-          end
+    def self.convert_linklist_urls(linklist, request_host, request_port)
+      linklist.map do |link_data|
+        if link_data.has_key?(:url)
+          link_data.delete(:obj_id)
+          url = link_data.delete(:url)
+          link = Link.parse(url, request_host, request_port)
+          link_data.merge!(link.to_cms_api_linklist_params)
         end
-      end
 
-      target
-    end
-
-    def self.internal_url?(uri, request_host, request_port)
-      if request_host == uri.host
-        if uri.port.present?
-          uri.port == Integer(request_port)
-        else
-          true
-        end
-      else
-        false
-      end
-    end
-
-    def self.convert_single_link(uri)
-      uri.path = '/' unless uri.path.present?
-      uri.port = nil
-      uri.host = nil
-      uri.scheme = nil
-
-      if obj_id = determine_obj_id(uri.to_s)
-        uri.scheme = 'objid'
-        uri.path = obj_id
-      else
-        uri.scheme = 'external'
-      end
-
-      uri.to_s
-    end
-
-    def self.determine_obj_id(target)
-      route = Rails.application.routes.recognize_path(target, :method => :get)
-      if route[:controller] == 'rails_connector/cms_dispatch'
-        begin
-          if id = route[:id]
-            Obj.find(id).id
-          elsif permalink = route[:permalink]
-            CmsEnv.find_permalink_by_param(permalink).id
-          end
-        rescue RailsConnector::ResourceNotFound
-        end
+        link_data
       end
     end
   end