objs_controller.rb in scrivito_sdk-0.30.0.rc1

- old
+ new
@@ -1,220 +1,208 @@
 module Scrivito
-
   class ObjsController < WebserviceController
-    around_action :authorize_selected_workspace_read,
-        only: [:details, :page_class_selection, :widget_class_selection, :search]
+    around_action :require_selected_workspace_write_authorization, only: [
+      :copy,
+      :create,
+      :destroy,
+      :destroy_widget,
+      :duplicate,
+      :mark_resolved,
+      :restore,
+      :revert,
+      :revert_widget,
+      :update,
+    ]
 
-    around_action :authorize_selected_workspace_write,
-        only: [:create, :update, :destroy, :destroy_widget, :revert, :restore, :mark_resolved,
-               :copy, :duplicate]
+    before_filter :require_identical_selected_and_visible_workspace, only: [
+      :copy,
+      :create,
+      :duplicate,
+      :page_class_selection,
+      :update,
+      :widget_class_selection,
+    ]
 
-    before_filter :ensure_identical_selected_and_visible_workspace,
-        only: [:create, :update, :copy, :duplicate, :page_class_selection, :widget_class_selection]
-
     def create
-      created_obj = task_unaware_request(:post,
-        "workspaces/#{selected_workspace.id}/objs",
-        {obj: obj_params}
-      )
-      render json: created_obj
+      obj_params = obj_params_parser.parse(nil, params[:obj])
+      @obj = selected_workspace.task_unaware_api_request(:post, '/objs', obj: obj_params)
     end
 
     def details
-      load_object
-      render json: {markup: render_to_string(@obj.details_view_path, layout: false)}
+      @markup = render_to_string(current_obj.details_view_path, layout: false, formats: :html)
     end
 
     def update
-      load_object
-      changed_obj = task_unaware_request(:put,
-        "workspaces/#{selected_workspace.id}/objs/#{params[:id]}",
-        {obj: obj_params}
-      )
-      render json: changed_obj
+      obj_params = obj_params_parser.parse(current_obj, params[:obj])
+      @api_response = selected_workspace
+          .task_unaware_api_request(:put, "/objs/#{params[:id]}", obj: obj_params)
     end
 
     def destroy
-      in_selected_workspace { load_object.destroy }
+      in_selected_workspace { current_obj.destroy }
       render_empty_json
     end
 
     def destroy_widget
-      raise ScrivitoError, "no widget_id param specified" if params[:widget_id].blank?
-      in_selected_workspace do
-        widget = load_object.widget_from_pool(params[:widget_id])
-        unless widget
-          raise ScrivitoError,
-              "widget with ID '#{params[:widget_id]}' not found in obj with ID '#{@obj.id}'"
-        end
-        widget.destroy
-      end
+      in_selected_workspace { current_widget.destroy }
       render_empty_json
     end
 
     def revert
-      in_selected_workspace { load_object.revert }
+      in_selected_workspace { current_obj.revert }
       render_empty_json
     end
 
+    def revert_widget
+      in_selected_workspace { current_widget.revert }
+      render_empty_json
+    end
+
     def restore
       in_selected_workspace { Obj.restore(params[:id]) }
       render_empty_json
     end
 
     def mark_resolved
-      in_selected_workspace { load_object.mark_resolved }
+      in_selected_workspace { current_obj.mark_resolved }
       render_empty_json
     end
 
     def copy
-      render json: copy_obj(load_object, params[:parent_path])
+      @attributes = copy_obj(current_obj, params[:parent_path])
     end
 
     def duplicate
-      load_object
-
-      render json: copy_obj(@obj, parent_path(@obj.path))
+      @attributes = copy_obj(current_obj, current_obj.parent_path)
+      render :copy
     end
 
     def page_class_selection
-      valid_page_classes = Obj.valid_page_classes_beneath(params[:parent_path]) ||
-          Obj.descendants
-      valid_page_classes.map!(&:to_s)
-
-      page_class_names = valid_page_classes.map do |page_class_name|
+      @page_class_markup = valid_page_classes.map do |page_class_name|
         begin
-          markup = render_to_string("#{page_class_name.underscore}/thumbnail")
+          markup = render_to_string("#{page_class_name.underscore}/thumbnail", formats: :html)
           {name: page_class_name, markup: markup}
         rescue ActionView::MissingTemplate
         end
       end
-
-      render json: page_class_names.compact
+      @page_class_markup.compact!
     end
 
     def widget_class_selection
-      load_object
-      valid_widget_classes = @obj.valid_widget_classes_for(params[:field_name]) ||
-          Widget.descendants
-      valid_widget_classes.map!(&:to_s)
+      load_obj
 
-      widgets_classes = valid_widget_classes.map do |widget_class_name|
+      @widgets_classes = valid_widget_classes.map do |widget_class_name|
         template_path = "#{widget_class_name.underscore}/thumbnail"
         markup = begin
-          render_to_string(template_path, layout: false)
+          render_to_string(template_path, layout: false, formats: :html)
         rescue ActionView::MissingTemplate
-          render_to_string('scrivito/widget_thumbnail', layout: false,
+          render_to_string('scrivito/widget_thumbnail', layout: false, formats: :html,
               locals: {widget_class_name: widget_class_name, template_path: template_path})
         end
         {name: widget_class_name, markup: markup}
       end
-
-      render json: widgets_classes
     end
 
     def search
       in_selected_workspace do
-        query = MultiJson.decode(params[:query]).with_indifferent_access
-        search_builder = ObjSearchBuilder.new(query)
-        enumerator = search_builder.build
-        formatter = fetch_formatter(query[:format])
+        @query = MultiJson.decode(params[:query]).with_indifferent_access
+        @enumerator = ObjSearchBuilder.new(@query).build
 
         if params[:query_action] == 'size'
-          render json: { total: enumerator.size }
-        elsif formatter
-          batch = enumerator.load_batch
-
-          result = {
-            total: enumerator.size,
-            hits: batch.map { |obj| formatter.call(obj, scrivito_user) }
-          }
-
-          render json: result
+          render :search_only_size
+        elsif @formatter = fetch_formatter(@query[:format])
+          render :search
         else
-          render json: { error: format_missing_message(query[:format]) }, status: :not_found
+          render :format_missing_error, status: :not_found
         end
       end
     end
 
-    private
+    def modification
+      in_selected_workspace { render }
+    end
 
-    def load_object
-      @obj = Obj.find(params[:id])
+    def widget_modification
+      in_selected_workspace { render }
     end
 
-    def ensure_identical_selected_and_visible_workspace
+    private
+
+    def require_identical_selected_and_visible_workspace
       if selected_workspace != editing_context.visible_workspace
-        raise ScrivitoError, "selected and visible workspace are not identical"
+        raise ScrivitoError, 'selected and visible workspace are not identical'
       end
     end
 
-    def obj_params
-      @obj_params ||= ObjParamsParser.new(request.host, request.port).parse(@obj, params[:obj])
+    def require_selected_workspace_write_authorization(&block)
+      authorize_workspace_access(:write, selected_workspace, &block)
     end
 
-    def copy_obj(obj, target_path)
-      id = SecureRandom.hex(8)
+    def in_selected_workspace(&block)
+      selected_workspace.as_current(&block)
+    end
 
-      copied_obj = obj.copy(_id: id, _path: "#{target_path}/#{id}")
-      dumped_last_changed = CmsRestApi::AttributeSerializer
-          .convert_time(copied_obj[:_last_changed])
-
-      {
-        _id: copied_obj[:_id],
-        _last_changed: dumped_last_changed,
-        _obj_class: copied_obj[:_obj_class_name],
-        _path: copied_obj[:_path],
-      }
+    def selected_workspace
+      editing_context.selected_workspace
     end
 
-    def get_obj_attributes(id)
-      task_unaware_request(:get, "workspaces/#{selected_workspace.id}/objs/#{id}")
+    def current_obj
+      @obj || load_obj
     end
+    helper_method :current_obj
 
-    def parent_path(path)
-      path.split('/')[0..-2].join('/')
+    def load_obj
+      @obj = Obj.find(params[:id])
     end
 
-    def current_page
-      Obj.find(params[:current_page_id]) if params[:current_page_id].present?
+    def current_widget
+      @widget || load_widget
     end
-    helper_method :current_page
+    helper_method :current_widget
 
-    delegate :task_unaware_request, to: CmsRestApi
-
-    private
-
-    def authorize_selected_workspace_read(&block)
-      authorize_workspace_access(:read, selected_workspace, &block)
+    def load_widget
+      raise ScrivitoError, 'no widget_id param specified' if params[:widget_id].blank?
+      unless @widget = current_obj.widget_from_pool(params[:widget_id])
+        raise ScrivitoError, "widget with ID '#{params[:widget_id]}' not found"
+      end
+      @widget
     end
 
-    def authorize_selected_workspace_write(&block)
-      authorize_workspace_access(:write, selected_workspace, &block)
+    def copy_obj(obj, target_path)
+      id = SecureRandom.hex(8)
+      copied_obj = obj.copy(_id: id, _path: "#{target_path}/#{id}")
+      dumped_last_changed = CmsRestApi::AttributeSerializer.convert_time(copied_obj[:_last_changed])
+      {
+        _id: copied_obj[:_id],
+        _last_changed: dumped_last_changed,
+        _obj_class: copied_obj[:_obj_class_name],
+        _path: copied_obj[:_path],
+      }
     end
 
-    def in_selected_workspace(&block)
-      selected_workspace.as_current(&block)
+    def fetch_formatter(name)
+      name ? Configuration.obj_formats[name] : proc { |obj, _| obj.id }
     end
 
-    def selected_workspace
-      @selected_workspace ||= editing_context.selected_workspace
+    def valid_page_classes
+      (Obj.valid_page_classes_beneath(params[:parent_path]) || Obj.descendants).map(&:to_s)
     end
 
-    def render_empty_json
-      render json: {}
+    def valid_widget_classes
+      (widget_classes_from_widget || widget_classes_from_obj || Widget.descendants).map(&:to_s)
     end
 
-    def fetch_formatter(name)
-      if name
-        Configuration.obj_formats[name]
-      else
-        proc { |obj, _| obj.id }
+    def widget_classes_from_widget
+      if params[:widget_id] && (widget = current_obj.widget_from_pool(params[:widget_id]))
+        widget.valid_widget_classes_for(params[:field_name])
       end
     end
 
-    def format_missing_message(format_name)
-      "The format with the name '#{format_name}' is not registered"
+    def widget_classes_from_obj
+      current_obj.valid_widget_classes_for(params[:field_name])
     end
-  end
 
+    def obj_params_parser
+      ObjParamsParser.new(request.host, request.port)
+    end
+  end
 end