scrivito_sdk 0.12.0

data/lib/scrivito/cms_field_tag.rb

@@ -0,0 +1,112 @@
+module Scrivito
+
+# this class is the server-side equivalent of the JavaScript class `cms_field_element`
+class CmsFieldTag < Struct.new(
+    :view_context, :editing_context, :obj_or_widget, :field_name
+  )
+
+  def options
+    formatted_options = {}
+    raw_options.each do |key, value|
+      formatted_options["data-scrivito-#{key}"] = value
+    end
+
+    formatted_options
+  end
+
+  def field_type
+    @field_type ||= obj_or_widget.type_of_attribute(field_name)
+  end
+
+  def default_content
+    calculate_content_and_modification
+    @content_and_modification.first
+  end
+
+  def modification_info
+    calculate_content_and_modification
+    @content_and_modification.second
+  end
+
+  private
+
+  def calculate_content_and_modification
+    @content_and_modification ||=
+      comparison.diff_for(obj_or_widget, field_name) || [current_value, nil]
+  end
+
+  def raw_options
+    return {} unless inplace_editing_allowed?
+
+    options = {
+      'private-field-workspace-id' => current_workspace_id,
+      'field-name'                 => field_name,
+      'field-obj-class'            => obj_or_widget.obj_class_name,
+      'field-type'                 => field_type,
+    }
+
+    modification = comparison.modification_for_attribute(obj_or_widget, field_name)
+    if modification == Modification::EDITED && field_type != 'widget'
+      options['field-modification'] = modification
+    end
+
+    if obj_or_widget.kind_of?(BasicWidget)
+      options['private-field-id'] = obj_or_widget.obj.id
+      options['private-field-widget-id'] = obj_or_widget.id
+    else
+      options['private-field-id'] = obj_or_widget.id
+    end
+
+    if FIELD_TYPES_WITH_ORIGINAL_CONTENT.include?(field_type)
+      original_value = view_context.display_original_value(current_value)
+      original_content = original_content(field_type, original_value)
+      options['private-field-original-content'] = MultiJson.encode(original_content)
+    end
+
+    if field_type == 'widget'
+      valid_widget_classes = obj_or_widget.valid_widget_classes_for(field_name.to_s)
+      if valid_widget_classes
+        options['private-field-widget-allowed-classes'] = valid_widget_classes.to_json
+      end
+    end
+
+    options
+  end
+
+  def comparison
+    editing_context.comparison
+  end
+
+  def current_value
+    obj_or_widget[field_name]
+  end
+
+  def current_workspace_id
+    Workspace.current.id
+  end
+
+  FIELD_TYPES_WITH_ORIGINAL_CONTENT = %w[
+    enum
+    html
+    multienum
+    reference
+    referencelist
+    string
+    text
+  ]
+
+  def inplace_editing_allowed?
+    editing_context.authenticated_editor?
+  end
+
+  def original_content(field_type, field_value)
+    case field_type
+    when 'reference' then field_value.try(:id)
+    when 'referencelist' then field_value.map(&:id)
+    else field_value
+    end
+  end
+
+end
+
+end

data/lib/scrivito/cms_rest_api.rb

@@ -0,0 +1,151 @@
+require 'restclient'
+require 'active_support/all'
+
+module Scrivito
+
+  # Provides a simple wrapper for the CMS Rest API.
+  #
+  # @example Request the published workspace:
+  #   Scrivito::CmsRestApi.get('workspaces/published')
+  #
+  # @example Create a new Obj:
+  #   Scrivito::CmsRestApi.post('workspaces/001384beff9e5845/objs',
+  #       {'obj' => {'_path' => '/new_obj', '_obj_class' => 'Publication'}})
+  #
+  # @example Update an Obj:
+  #   Scrivito::CmsRestApi.put('workspaces/001384beff9e5845/objs/9e432077f0412a63',
+  #       {'obj' => {'title' => 'new title'}})
+  #
+  # @example Delete an Obj:
+  #   Scrivito::CmsRestApi.delete('workspaces/001384beff9e5845/objs/f4123622ff07b70b')
+  #
+  # @example Specify a poll interval (in seconds; default: 2) to use in case the response
+  # is a task reference response and the final response is polled for:
+  #   Scrivito::CmsRestApi.put('workspace/rtc/publish', nil, :interval => 10)
+  #
+  # @example Return immediately with the first response (without polling in case it is a
+  # task reference response):
+  #   Scrivito::CmsRestApi.task_unaware_request(:put, 'workspace/rtc/publish', nil)
+  #
+  class CmsRestApi
+    METHOD_TO_NET_HTTP_CLASS = {
+      :get => Net::HTTP::Get,
+      :put => Net::HTTP::Put,
+      :post => Net::HTTP::Post,
+      :delete => Net::HTTP::Delete,
+    }.freeze
+
+    def self.get(resource_path, payload = nil, options = nil)
+      request_cms_api(:get, resource_path, payload, options)
+    end
+
+    def self.put(resource_path, payload, options = nil)
+      request_cms_api(:put, resource_path, payload, options)
+    end
+
+    def self.post(resource_path, payload, options = nil)
+      request_cms_api(:post, resource_path, payload, options)
+    end
+
+    def self.delete(resource_path, payload = nil, options = nil)
+      request_cms_api(:delete, resource_path, payload, options)
+    end
+
+    def self.task_unaware_request(method, resource_path, payload = nil)
+      raise "Unexpected method #{method}" unless [:delete, :get, :post, :put].include?(method)
+      response_for_request_cms_api(method, resource_path, payload)
+    end
+
+    class << self
+
+      private
+
+      def request_cms_api(action, resource_path, payload, options)
+        decoded = response_for_request_cms_api(action, resource_path, payload)
+        return decoded unless Hash === decoded
+        return decoded unless decoded.keys == ["task"]
+        task_data = decoded["task"]
+        return decoded unless Hash === task_data
+        task_path = "tasks/#{task_data["id"]}"
+        final_response(task_path, options)
+      end
+
+      def response_for_request_cms_api(method, resource_path, payload = nil)
+        request = method_to_net_http_class(method).new(path(resource_path))
+        set_headers(request)
+        request.body = MultiJson.encode(payload) if payload.present?
+
+        response = nil
+        retried = false
+        begin
+          # lower timeout back to DEFAULT_TIMEOUT once the backend has been fixed
+          response = connection_manager.request(request, 25)
+        rescue NetworkError => e
+          if method == :post || retried
+            raise e
+          else
+            retried = true
+            retry
+          end
+        end
+
+        handle_response(response)
+      end
+
+      def handle_response(response)
+        code = response.code.to_i
+        if response.code.start_with?('2')
+          MultiJson.load(response.body)
+        elsif response.code == '403'
+          raise AccessDenied.new(response.body)
+        else
+          begin
+            specific_output = MultiJson.decode(response.body)['error']
+
+            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 NetworkError.new(response.body, code)
+          end
+        end
+      end
+
+      def final_response(task_path, options)
+        options ||= {}
+        wait = options[:interval].presence.try(:to_f) || 2
+        task_data = response = nil
+        loop do
+          sleep wait
+          task_data = response_for_request_cms_api(:get, task_path, nil)
+          break unless task_data["status"] == "open"
+        end
+        return task_data["result"] if task_data["status"] == "success"
+        message = task_data["message"] || "Missing error message in task response #{task_data}"
+        raise ClientError.new(message, 400)
+      end
+
+      def set_headers(request)
+        request.basic_auth('api_token', Configuration.api_key)
+        request['Content-type'] = 'application/json'
+        request['Accept'] = 'application/json'
+      end
+
+      def path(path)
+        "/#{Configuration.endpoint_uri.path}/#{path}".squeeze('/')
+      end
+
+      def connection_manager
+        ConnectionManager.instance
+      end
+
+      def method_to_net_http_class(method)
+        METHOD_TO_NET_HTTP_CLASS.fetch(method)
+      end
+    end
+  end
+end

data/lib/scrivito/cms_rest_api/attribute_serializer.rb

@@ -0,0 +1,98 @@
+module Scrivito
+  class CmsRestApi
+    module AttributeSerializer
+      class << self
+
+        def generate_widget_pool_changes(widget_hash)
+          widget_pool_changes = {}
+
+          widget_hash.each do |widget, attributes|
+            if attributes.present?
+              widget_pool_changes[widget.id] =
+                self.convert(attributes)
+            else # Empty hash or nil
+              widget_pool_changes[widget.id] = attributes
+            end
+          end
+
+          widget_pool_changes
+        end
+
+        def convert(attributes)
+          Hash[
+            attributes.map do |attribute_name, value|
+              attribute_name = attribute_name.to_s
+
+              converted_value = if value.nil? || value == []
+                nil
+              elsif link_array?(value)
+                convert_links(value)
+              elsif value.is_a?(BasicObj)
+                value.id
+              elsif widget_array?(value)
+                convert_widgets(value)
+              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)
+                Scrivito::CmsRestApi::BlobUploader.upload_file(value)
+              else
+                value.to_s
+              end
+
+              [attribute_name, converted_value]
+            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
+
+        private
+
+        def widget_array?(value)
+          value.is_a?(Array) && value.all? do |element|
+            element.is_a?(BasicWidget)
+          end
+        end
+
+        def convert_widgets(value)
+          converted_widgets = value.map do |widget|
+            { 'widget' => widget.id }
+          end
+
+          { 'list' => converted_widgets }
+        end
+
+        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
+
+      end
+    end
+  end
+end

data/lib/scrivito/cms_rest_api/blob_uploader.rb

@@ -0,0 +1,18 @@
+module Scrivito
+  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/scrivito/cms_rest_api/widget_extractor.rb

@@ -0,0 +1,42 @@
+module Scrivito
+  class CmsRestApi
+    class WidgetExtractor
+
+      # Extract widgets from a given attribute tree and return them as a flat
+      # hash of widget_like => updated_attributes
+      def self.call(updated_attributes, obj=nil)
+        extracted_widgets = {}
+
+        updated_attributes.each do |attribute_name, value|
+          if value.is_a?(Array) && value.all? {|w| w.is_a?(BasicWidget)}
+            value.each do |widget|
+              unless widget.persisted?
+                widget.id = if obj.present?
+                  obj.generate_widget_pool_id
+                else
+                  BasicObj.generate_widget_pool_id
+                end
+
+                widget.obj = obj
+
+                extracted_widgets[widget] = widget.attributes_to_be_saved
+                extracted_widgets.merge!(self.call(widget.attributes_to_be_saved, obj))
+              end
+            end
+          end
+        end
+
+        extracted_widgets
+      end
+
+      def self.notify_persisted_widgets(obj, widget_hash)
+        widget_hash.each do |widget, attributes|
+          if attributes.present?
+            widget.obj = obj
+            widget.forget_unsaved_attribtues
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scrivito/cms_test_request.rb

@@ -0,0 +1,23 @@
+module Scrivito
+  module CmsTestRequest
+    def for_cms_object(test_obj=nil)
+      # prepare the env as if the given obj was loaded by CmsEnv
+      env[Scrivito::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::RoutingError, AbstractController::ActionNotFound => e
+          begin
+            super(routes, "scrivito/cms_dispatch", action, parameters)
+          rescue ActionController::RoutingError, AbstractController::ActionNotFound
+            raise e
+          end
+        end
+      end
+    end
+  end
+end