infopark_fiona7 0.30.0.1

data/lib/fiona7/builder/obj_updater.rb

@@ -0,0 +1,25 @@
+require 'fiona7/builder/obj_builder'
+#require 'fiona7/write_obj'
+
+module Fiona7
+  module Builder
+    class ObjUpdater < ObjBuilder
+      protected
+      def validate
+        # revert command sends this info. which is silly.
+        @values.delete(:_last_changed)
+
+        return true
+      end
+
+      def create_object
+        @obj_id = @values.delete(:_id)
+        @obj = WriteObj.find(@obj_id)
+        @obj.name = @name unless @name.blank?
+        @name = @obj.name
+        @obj_class ||= @obj.obj_class
+        # TODO: move (parent change)
+      end
+    end
+  end
+end

data/lib/fiona7/builder/widget_builder.rb

@@ -0,0 +1,13 @@
+require 'fiona7/builder/obj_builder'
+require 'fiona7/builder/widget_building'
+
+module Fiona7
+  module Builder
+    class WidgetBuilder < ObjBuilder
+      include WidgetBuilding
+      def initialize(owner_obj, widget_id, values, path_map)
+        @owner_obj, @widget_id, @values, @widget_path_map = owner_obj, widget_id, values.symbolize_keys, path_map
+      end
+    end
+  end
+end

data/lib/fiona7/builder/widget_building.rb

@@ -0,0 +1,35 @@
+module Fiona7
+  module Builder
+    module WidgetBuilding
+      def path
+        @obj.path
+      end
+
+      def build
+        super
+      end
+
+      protected
+
+      def prepare_object
+        raise Scrivito::ScrivitoError, "Inconsistent internal state: unable to create widgets for nonexiting parent." if @owner_obj.path.nil?
+        # only publication type can contain children (code = "5")
+        # also handle / this way
+        if @owner_obj.obj_type_code != "5" || @owner_obj.id == 2001
+          parent_path = "/_widgets/#{@owner_obj.id}"
+        else
+          parent_path = "#{@owner_obj.path}/_widgets"
+        end
+        @path       = "#{parent_path}/#{@widget_id}"
+        @name       = @widget_id.to_s
+        @parent     = ensure_parent_exists(parent_path)
+        raise Scrivito::ScrivitoError, "Error storing widget, container #{parent_path.inspect} not found." if @parent.nil?
+        @obj_class  = @values.delete(:_obj_class)
+      end
+
+      def write_widget_pool
+        # NOP
+      end
+    end
+  end
+end

data/lib/fiona7/builder/widget_updater.rb

@@ -0,0 +1,13 @@
+require 'fiona7/builder/obj_updater'
+require 'fiona7/builder/widget_building'
+
+module Fiona7
+  module Builder
+    class WidgetUpdater < ObjUpdater
+      include WidgetBuilding
+      def initialize(owner_obj, widget_id, values, path_map)
+        @owner_obj, @widget_id, @values, @widget_path_map = owner_obj, widget_id, values.symbolize_keys, path_map
+      end
+    end
+  end
+end

data/lib/fiona7/controllers/content_service/obj_controller.rb

@@ -0,0 +1,125 @@
+require 'set'
+#require 'fiona7/released_obj'
+#require 'fiona7/edited_obj'
+require 'fiona7/assert'
+require 'fiona7/workspace'
+require 'fiona7/json/obj_decorator'
+
+module Fiona7
+  module Controllers
+    module ContentService
+      class ObjController
+        SCRIVITO_DIFF_MODE_BROKEN = true
+
+        def fetch_multiple(params)
+          @queries     = params[:queries]
+          workspace_id = params[:workspace_id]
+          revision_id  = params[:revision_id]
+          @klass       = self.get_matching_class(workspace_id, revision_id)
+
+          all_refs = Set.new
+          all_objs = Set.new
+
+          @queries.each do |query|
+            objs, refs = process_query(query)
+
+            all_objs.merge(objs)
+            all_refs << refs
+          end
+
+          r = {results: all_refs, objs: all_objs}
+          return ::JSON.parse(::ActiveSupport::JSON.encode(r))
+        end
+
+        protected
+        def get_matching_class(workspace_id, revision_id)
+          Assert.input(
+            workspace_id.nil? || (
+              workspace_id == 'published' || workspace_id == 'rtc'
+            ),
+            "Invalid workspace_id: #{workspace_id}"
+          )
+
+          if workspace_id && !SCRIVITO_DIFF_MODE_BROKEN
+            workspace_id == 'published' ? ReleasedObj : EditedObj
+          elsif revision_id
+            # no workspace_id given, we need to go by revision_id
+            rtc_workspace = Workspace.rtc
+            published_workspace = Workspace.published
+
+            # in most cases a query without workspace_id is caused
+            # by modification calculation, which compares the object
+            # with it's base revision (i.e. revision of published)
+            if revision_id[0] == 'f' && published_workspace.revision_id == revision_id
+              ReleasedObj
+            elsif revision_id[0] == 'b' && rtc_workspace.revision_id == revision_id
+              EditedObj
+            else
+              # we don't know this revision (anymore), it may be that
+              # the content has been changed between requests (concurrent
+              # modification may cause race conditions),
+              # but we know that published revisions start with a 'f'
+              # and rtc revisions start with a 'b'
+              if revision_id[0] == 'f'
+                ReleasedObj
+              elsif revision_id[0] == 'b'
+                EditedObj
+              else
+                Assert.input(
+                  false,
+                  "Invalid revision_id received: #{revision_id}"
+                )
+              end
+            end
+          else
+            Assert.input(
+              false,
+              "Neither workspace_id nor revision_id given, unable to identify content"
+            )
+          end
+        end
+
+        def process_query(query)
+          objs = case query[:type]
+                 when "id"
+                   find_by_id(query[:param])
+                 when "path"
+                   find_by_path(query[:param])
+                 when "ppath"
+                   find_by_parent_path(query[:param])
+                 when "permalink"
+                   find_by_permalink(query[:param])
+                 else
+                   Assert.input(
+                     false,
+                     "Invalid query type #{query[:type]}"
+                   )
+                 end
+
+          refs = {"refs" => objs.map {|o| {"id" => o.id} } }
+          objs = objs.map {|o| JSON::ObjDecorator.new(@klass, o) }
+
+          return objs, refs
+        end
+
+        def find_by_id(id)
+          @klass.where(obj_id: id).limit(1).to_a
+        end
+
+        def find_by_path(path)
+          path = path.gsub('.', '_')
+          @klass.where(path: path).limit(1).to_a
+        end
+
+        def find_by_parent_path(path)
+          parent = @klass.find_by_path(path)
+          parent ? parent.children : []
+        end
+
+        def find_by_permalink(permalink)
+          @klass.where(permalink: permalink).limit(1).to_a
+        end
+      end
+    end
+  end
+end

data/lib/fiona7/controllers/content_service/workspace_controller.rb

@@ -0,0 +1,19 @@
+require 'fiona7/workspace'
+require 'fiona7/assert'
+
+module Fiona7
+  module Controllers
+    module ContentService
+      class WorkspaceController
+        def fetch(playload)
+          id = playload[:workspace_id]
+          id = id.to_sym
+          return {} if id != :published && id != :rtc
+
+          w = {'workspace' => Workspace.new(id)}
+          return ::JSON.parse(::ActiveSupport::JSON.encode(w))
+        end
+      end
+    end
+  end
+end

data/lib/fiona7/controllers/rest_api/blob_controller.rb

@@ -0,0 +1,11 @@
+module Fiona7
+  module Controllers
+    module RestAPI
+      class BlobController
+        def fetch(blob_id)
+          raise ::Scrivito::ClientError.new("This API is not supported by Fiona7 and should not be called, try using Scrivito::Binary#content or scrivito_url(obj) when appropriate", 412)
+        end
+      end
+    end
+  end
+end

data/lib/fiona7/controllers/rest_api/obj_class_controller.rb

@@ -0,0 +1,39 @@
+require 'fiona7/builder/obj_class_builder'
+require 'fiona7/builder/obj_class_updater'
+require 'fiona7/json/obj_class_decorator'
+require 'fiona7/type_register'
+
+module Fiona7
+  module Controllers
+    module RestAPI
+      class ObjClassController
+        def all
+          # ObjClasses with X_ prefix are hidden, so is Root (temporarily)
+          cms_classes = RailsConnector::ObjClass.all.select {|o| o.name != 'Root' && o.name !~ /\AX_/ }.map {|cms_class| JSON::ObjClassDecorator.new(cms_class) }
+          return ::JSON.parse(::ActiveSupport::JSON.encode({results: cms_classes}))
+        end
+
+        def create(workspace_id, values)
+          raise "Unexpected workspace_id: #{workspace_id}" unless workspace_id.to_s == "rtc"
+          cms_class = JSON::ObjClassDecorator.new(Builder::ObjClassBuilder.new(values[:obj_class].dup).build)
+          return ::JSON.parse(::ActiveSupport::JSON.encode(cms_class))
+        end
+
+        def update(workspace_id, values)
+          raise "Unexpected workspace_id: #{workspace_id}" unless workspace_id.to_s == "rtc"
+          cms_class = JSON::ObjClassDecorator.new(Builder::ObjClassUpdater.new(values[:obj_class].dup).build)
+          # invalidate caches:
+          TypeRegister.instance.invalidate_cached_type(cms_class.name)
+          return ::JSON.parse(::ActiveSupport::JSON.encode(cms_class))
+        end
+
+        def fetch(workspace_id, name)
+          # TODO: assert workspace_id
+          cms_class = JSON::ObjClassDecorator.new(RailsConnector::ObjClass.find_by_obj_class_name(name))
+          return ::JSON.parse(::ActiveSupport::JSON.encode(cms_class))
+        end
+      end
+    end
+  end
+end
+

data/lib/fiona7/controllers/rest_api/obj_controller.rb

@@ -0,0 +1,175 @@
+#require 'fiona7/write_obj'
+#require 'fiona7/released_obj'
+#require 'fiona7/edited_obj'
+
+require 'fiona7/builder/obj_builder'
+require 'fiona7/builder/obj_updater'
+
+require 'fiona7/naive_search_engine'
+
+require 'fiona7/assert'
+
+require 'fiona7/json/typeless_obj_decorator'
+
+module Fiona7
+  module Controllers
+    module RestAPI
+      class ObjController
+        def create(workspace_id, values)
+          assert_writable(workspace_id)
+
+          # This is a hack to make it seem as if the root obj does not exist
+          if values[:obj][:_path] != '/' && values[:obj]["_path"] != '/'
+            obj = Builder::ObjBuilder.new(values[:obj].dup).build
+          else
+            obj = Builder::ObjUpdater.new(values[:obj].merge(_id: 2001)).build
+          end
+
+          klass = EditedObj
+          decorated = Fiona7::JSON::TypelessObjDecorator.new(klass, obj)
+          
+          return ::JSON.parse(::ActiveSupport::JSON.encode(decorated))
+        end
+
+        def fetch_by_path(workspace_id, path)
+          klass = matching_class(workspace_id)
+
+          path = path.gsub('.', '_')
+          obj = klass.find_by_path(path)
+
+          Assert.input(
+            !obj.nil?,
+            "Obj with path #{path} not found in workspace #{workspace_id}",
+            404
+          )
+
+          decorated = Fiona7::JSON::TypelessObjDecorator.new(klass, obj)
+          return ::JSON.parse(::ActiveSupport::JSON.encode(decorated))
+        end
+
+        def fetch_by_id(workspace_id, obj_id)
+          klass = matching_class(workspace_id)
+          obj = klass.where(obj_id: obj_id).first
+
+          Assert.input(
+            !obj.nil?,
+            "Obj with id #{obj_id} not found in workspace #{workspace_id}",
+            404
+          )
+
+          decorated = Fiona7::JSON::TypelessObjDecorator.new(klass, obj)
+          return ::JSON.parse(::ActiveSupport::JSON.encode(decorated))
+        end
+
+        def fetch_by_id_from_revision(revision_id, obj_id)
+          # TODO: use implementation from ContentService controller
+          # FIXME: code duplication with fetch_by_id
+          klass = revision_id.start_with?('f') ? ReleasedObj : EditedObj
+          obj = klass.where(obj_id: obj_id).first
+
+          Assert.input(
+            !obj.nil?,
+            "Obj with id #{obj_id} not found in revision #{revision_id}",
+            404
+          )
+
+          decorated = Fiona7::JSON::TypelessObjDecorator.new(klass, obj)
+          return ::JSON.parse(::ActiveSupport::JSON.encode(decorated))
+        end
+
+        def search(workspace_id, params)
+          klass = matching_class(workspace_id)
+
+          offset = params[:offset] || 0
+          size   = params[:size] || 100
+          query  = params[:query] || []
+          order  = (params[:sort_order] || :asc).to_sym
+          sort   = (params[:sort_by] || :id).to_sym
+
+          search = NaiveSearchEngine.new(klass, query, offset, size, sort, order)
+          result = search.results.map {|o| {id: o.id} }
+          total  = search.total
+
+          return ::JSON.parse(::ActiveSupport::JSON.encode({
+            total: total,
+            results: result
+          }))
+        end
+
+        def update(workspace_id, values)
+          assert_writable(workspace_id)
+
+          obj = Builder::ObjUpdater.new(values[:obj].dup.with_indifferent_access).build
+          klass = EditedObj
+          decorated = Fiona7::JSON::TypelessObjDecorator.new(klass, obj)
+          return ::JSON.parse(::ActiveSupport::JSON.encode(decorated))
+        end
+
+        def destroy(workspace_id, obj_id)
+          # TODO: cleanup /_widgets and /_uploads
+          obj = WriteObj.find(obj_id)
+          if !obj.children.empty?
+            if obj.children.all? {|c| c.name == '_widgets' || c.name == '_uploads' }
+              remove_obj_tree(obj)
+            else
+              Assert.input(
+                false,
+                "Cannot remove object #{obj_id} because it has children objects"
+              )
+            end
+          else
+            obj.destroy
+          end
+          return {}
+        end
+
+        protected
+        def remove_obj_tree(rc_obj)
+          subtree_objects = WriteObj.where(["path like ?", "#{rc_obj.path}/%"])
+          tree = ([rc_obj] + subtree_objects).sort_by{|obj| obj.path}.reverse
+          outside_objects = []
+          tree.each do |obj|
+            obj.super_objects.each do |super_object|
+              if !super_object.path.start_with?(rc_obj.path)
+                outside_objects << super_object
+              end
+            end
+          end
+          if outside_objects.length != 0
+            outsize_paths = outsize_objects.map(&:path).join(" ")
+            Assert.input(
+              false,
+              "Cannot remove object because #{outside_paths} have links pointing to it"
+            )
+          end
+          tree.each do |obj|
+            obj.send(:crul_obj).remove_archived_contents!
+            obj.send(:crul_obj).remove_active_contents!
+          end
+          tree.each do |obj|
+            obj.send(:crul_obj).delete!
+          end
+        end
+
+        def matching_class(workspace_id)
+          workspace_id = workspace_id.to_sym
+
+          Assert.input(
+            workspace_id == :rtc || workspace_id == :published,
+            "Workspace #{workspace_id} not found"
+          )
+
+          klass = workspace_id == :published ? ReleasedObj : EditedObj
+        end
+
+        def assert_writable(workspace_id)
+          workspace_id = workspace_id.to_sym
+          Assert.input(
+            workspace_id == :rtc,
+            "Workspace #{workspace_id} is not writable, only workspace rtc is writable"
+          )
+        end
+      end
+    end
+  end
+end