infopark_fiona7 0.30.0.1

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

@@ -0,0 +1,58 @@
+require 'fiona7/workspace'
+require 'fiona7/assert'
+
+module Fiona7
+  module Controllers
+    module RestAPI
+      class WorkspaceController
+        def fetch(id)
+          id = id.to_sym
+          Assert.input(
+            id == :published || id == :rtc,
+            "Workspace does not exist"
+          )
+
+          w = Workspace.new(id)
+          return ::JSON.parse(::ActiveSupport::JSON.encode(w))
+        end
+
+        def publish(id)
+          raise "Unexpected workspace_id: #{id}" unless id.to_s == "rtc"
+          WriteObj.where(is_edited: 1).each do |obj|
+            begin
+              obj.release!
+            rescue => e
+              raise "Release impossible of: #{obj.path} because: #{e.message}"
+            end
+          end
+          {'task' => {'id' => '1', 'status' => 'success', 'result' => '1'}}
+        end
+
+        def delete(id)
+          Assert.contraint(false, "Workspaces cannot be deleted")
+        end
+
+        def create(values)
+          id = (values[:workspace][:id] || values[:workspace]["id"])
+          id = id.to_sym
+          Assert.constraint(
+            id == :rtc,
+            "Only rtc workspace can be created"
+          )
+          w = Workspace.rtc
+          # NOTE: this "creates" a rtc workspace
+          # and breaks publish checker spec ...
+          #WriteObj.root.take ; WriteObj.root.edit
+
+          ::JSON.parse(::ActiveSupport::JSON.encode(w))
+        end
+
+        def all
+          results = [Workspace.published, Workspace.rtc]
+          w = {'results' => results}
+          ::JSON.parse(::ActiveSupport::JSON.encode(w))
+        end
+      end
+    end
+  end
+end

data/lib/fiona7/engine.rb

@@ -0,0 +1,138 @@
+require "fiona7/routing_monkey_patch"
+
+#require "active_record/railtie"
+
+require "scrivito"
+require "scrivito_sdk"
+require "scrivito_editors"
+
+require "scrivito/sdk_engine"
+
+require "infopark_fiona_connector"
+#require "rails_connector/engine"
+#require "rails_connector/fiona_engine" 
+require "infopark_reactor"
+
+require "fiona7/mode_switch"
+require "fiona7/scrivito_patches/attribute_content"
+require "fiona7/scrivito_patches/basic_obj"
+require "fiona7/scrivito_patches/basic_widget"
+require "fiona7/scrivito_patches/binary"
+require "fiona7/scrivito_patches/client_config"
+require "fiona7/scrivito_patches/controller_actions"
+require "fiona7/scrivito_patches/cms_dispatch_controller"
+require "fiona7/scrivito_patches/cms_rest_api"
+require "fiona7/scrivito_patches/cms_routing"
+require "fiona7/scrivito_patches/link_parser"
+require "fiona7/scrivito_patches/obj_class"
+require "fiona7/scrivito_patches/migrator"
+require "fiona7/scrivito_patches/type_computer"
+require "fiona7/scrivito_patches/workspace"
+
+
+require "fiona7/routers/content_service"
+require "fiona7/routers/rest_api"
+
+require 'fiona7/scrivito_user'
+
+module Fiona7
+  mattr_accessor :mode
+  mattr_accessor :login
+
+  class Config < Struct.new("Config", :mode, :instance, :host, :port, :username, :secret, :root_mode)
+  end
+
+  def self.configure(&block)
+    Config.new.tap do |config|
+      yield config
+
+      Reactor::Configuration.xml_access = {
+        host: config.host,
+        port: config.port,
+        id: 'f7',
+        username: config.username,
+        secret: config.secret
+      }
+
+      Fiona7.mode = config.mode
+      if Fiona7.login = !config.root_mode
+        Scrivito.configure do |config|
+          config.editing_auth do |env|
+            request  = ActionDispatch::Request.new(env)
+            session  = request.session
+            rsession = session[:rsession]
+            if rsession && rsession.user?
+              Fiona7::ScrivitoUser.define(rsession.user)
+            end
+          end
+
+          config.find_user do |user_id|
+            user = Reactor::Cache::User.instance.get(user_id)
+
+            Fiona7::ScrivitoUser.define(user)
+          end
+        end
+      end
+
+      if config.mode == :standalone
+        RailsConnector::Configuration.mode = :editor
+      end
+
+      RailsConnector::Configuration.instance_name = config.instance
+    end
+  end
+    
+  class Engine < ::Rails::Engine
+
+    initializer "fiona7.mode_switch" do |app|
+      mode = nil
+
+      if Fiona7.mode == :standalone
+        mode = :standalone
+      elsif Fiona7.mode == :legacy
+        mode = :legacy
+      else
+        raise "Invalid mode: #{Fiona7.mode}. Valid modes are :legacy and :standalone. Please refer to the documentation for more information"
+      end
+
+      ModeSwitch::Composite.new(app).public_send(mode)
+    end
+
+    initializer "fiona7.remove_scrivito_deprecations" do |app|
+      {
+        'cms_image_tag'               => 'scrivito_image_tag',
+        'cms_path'                    => 'scrivito_path',
+        'cms_tag'                     => 'scrivito_tag',
+        'cms_tag_list'                => 'scrivito_tag_list',
+        'cms_url'                     => 'scrivito_url',
+        'display_field'               => 'scrivito_field',
+        'display_value'               => 'scrivito_value',
+        'scrivito_after_content_tags' => 'scrivito_body_tags',
+        'scrivito_header_tags'        => 'scrivito_head_tags',
+      }.each_pair do |old_method_name, new_method_name|
+        ScrivitoHelper.send(:remove_method, old_method_name) if ScrivitoHelper.method_defined?(old_method_name)
+      end
+    end
+
+    initializer "fiona7.authorize_reactor" do |app|
+      ActionController::Base.__send__(:define_method, :rsession_auth) do
+        if !Fiona7.login
+          rsession.user_name = 'root' unless rsession.user_name == 'root'
+        end
+      end 
+    end
+
+    initializer "fiona7.patch_assets" do |app|
+      app.config.assets.precompile += %w(fiona7.css fiona7.js fiona7-login.css)
+    end
+
+    initializer "fiona7.runtime_patches" do |app|
+      # delayed init, patching sooner breaks AR
+      require "fiona7/fiona_connector_patches/basic_obj"
+    end
+
+    # This ensures that reactor is loaded in the app
+    config.after_initialize { Fiona7::WriteObj }
+
+  end
+end

data/lib/fiona7/fiona_connector_patches/basic_obj.rb

@@ -0,0 +1,9 @@
+require 'rails_connector/basic_obj'
+
+module RailsConnector
+  class BasicObj
+    def scrivito_obj
+      Scrivito::Obj.find(self.id)
+    end
+  end
+end

data/lib/fiona7/initializer.rb

@@ -0,0 +1,78 @@
+module Fiona7
+  class Initializer
+    CLASSES_MAP = {
+      'X_Generic'      => 'generic',
+      'X_Image'        => 'image',
+      'X_Container'    => 'publication'
+    }
+
+    ATTRIBUTES_MAP = {
+      'X_widget_pool'  => 'linklist'
+    }
+
+    def sanity_check
+      any_class_present = false
+      classes_present = CLASSES_MAP.all? do |name, type|
+        obj_class = RailsConnector::ObjClass.find_by_name(name)
+        any_class_present ||= obj_class && obj_class.obj_type == type
+      end
+
+      classes_present && raise("Initialization has already been performed, there is not need to perform it again.")
+      any_class_present && raise("Misconfiguration of obj classes detected")
+
+      any_attribute_present = false
+      attributes_present = ATTRIBUTES_MAP.all? do |name, type|
+        attribute = RailsConnector::Attribute.find_by_name(name)
+        any_attribute_present ||= attribute && attribute.attribute_type == type
+      end
+
+      any_class_present && raise("Misconfiguration of attributes detected")
+    end
+
+    def classes_and_attributes
+      CLASSES_MAP.each do |name, type|
+        Reactor::Cm::ObjClass.create(name, type)
+      end
+
+      ATTRIBUTES_MAP.each do |name, type|
+        Reactor::Cm::Attribute.create(name, type)
+      end
+    end
+
+    def set_valid_sub_obj_classes
+      RailsConnector::ObjClass.all.each do |obj_class|
+        valid_sub_obj_classes = read_valid_sub_obj_classes(obj_class)
+
+        # empty valid_sub_obj_classes = allow all
+        unless valid_sub_obj_classes.empty?
+          valid_sub_obj_classes += CLASSES_MAP.keys
+          cm_class = Reactor::Cm::ObjClass.get(obj_class.name)
+          cm_class.set(:validSubObjClasses, valid_sub_obj_classes)
+          cm_class.save!
+        end
+      end
+    end
+
+    def create_login_page
+      Scrivito::Workspace.current = Scrivito::Workspace.find('rtc')
+      Scrivito::ObjClass.create(
+        name: 'Fiona7LoginPage',
+        title: 'Login Page',
+        attributes: [
+          {name: "title", type: "string"},
+          {name: "body", type: "html"}
+        ]
+      )
+      Scrivito::Obj.create(_obj_class: 'Fiona7LoginPage', _path: '/_global/login_page', title: 'Log in')
+      Scrivito::ObjClass.find('Fiona7LoginPage').update(is_active: false)
+    end
+
+    protected
+    def read_valid_sub_obj_classes(obj_class)
+      # TODO: upgrade reactor to get rid of this crap
+      obj_class.send(:load_blob_data)
+      data = obj_class.instance_variable_get('@blob_data') || {}
+      data["validSubObjClasses"] || []
+    end
+  end
+end

data/lib/fiona7/json/obj_class_decorator.rb

@@ -0,0 +1,45 @@
+require 'fiona7/type_register_mixin'
+
+module Fiona7
+  module JSON
+    class ObjClassDecorator
+      include TypeRegisterMixin
+
+      attr_reader :cms_class
+
+      def initialize(cms_class)
+        @cms_class = cms_class
+      end
+
+      def name
+        cms_class.name
+      end
+
+      def as_json(*options)
+        result = {
+          id: cms_class.name,
+          name: cms_class.name,
+          title: cms_class.title(:de),
+          #type: cms_class.obj_type,
+          is_active: cms_class.enabled?,
+          attributes: []
+        }
+        type_register.annotated_attributes(cms_class.name).each do |attribute|
+          virtual_name = attribute.virtual_name
+          virtual_type = attribute.virtual_type
+
+          attr_hash = {
+            name: virtual_name.to_s,
+            type: virtual_type.to_s
+          }
+
+          attr_hash[:values] = attribute.values if attribute.values
+
+          result[:attributes] << attr_hash
+        end
+
+        result.as_json(*options)
+      end
+    end
+  end
+end

data/lib/fiona7/json/obj_decorator.rb

@@ -0,0 +1,153 @@
+module Fiona7
+  module JSON
+    class ObjDecorator
+    end
+  end
+end
+
+require 'fiona7/assert'
+require 'fiona7/type_register_mixin'
+require 'fiona7/link_converter/fiona_to_scrivito'
+require 'fiona7/json/widget_decorator'
+require 'fiona7/widget_resolver'
+
+module Fiona7
+  module JSON
+    class ObjDecorator
+      include TypeRegisterMixin
+
+      def initialize(klass, obj)
+        @klass = klass
+        @obj = obj
+
+        @link_converter = LinkConverter::FionaToScrivito.new(obj)
+      end
+
+      def as_json(*args)
+        attrs = standard_attrs
+        add_custom_attributes(attrs, *args)
+        replace_widget_pool(attrs, *args)
+
+        attrs
+      end
+
+      protected
+      def standard_attrs
+        attrs = {
+          _id: [@obj.id],
+          _path: [@obj.path],
+          _obj_class: [@obj.obj_class],
+          _last_changed: [@obj.last_changed.try(:to_iso)],
+          _widget_pool: [{}]
+        }
+        attrs[:_permalink] = [@obj.permalink] if @obj.permalink.present?
+        attrs
+      end
+
+      def add_custom_attributes(attrs, *args)
+        type_register.annotated_attributes(@obj.obj_class).each do |attribute|
+          virtual_attribute_name = attribute.virtual_name
+          real_attribute_name    = attribute.real_name
+          virtual_attribute_type = attribute.virtual_type
+
+          val = case virtual_attribute_type
+          when :link
+            deserialize_link(@obj[real_attribute_name].try(:first))
+          when :linklist
+            (@obj[real_attribute_name] || []).map {|link| deserialize_link(link) }
+          when :multienum
+            @obj[real_attribute_name] || []
+          when :reference
+            deserialize_reference(@obj[real_attribute_name].try(:first))
+          when :referencelist
+            (@obj[real_attribute_name] || []).map {|link| deserialize_reference(link) }.compact
+          when :date
+            @obj[real_attribute_name].try(:to_iso)
+          when :widget
+            deserialize_widget_field(@obj[real_attribute_name] || [])
+          when :html
+            deserialize_html(@obj[real_attribute_name])
+          when :binary
+            deserialize_binary(@obj[real_attribute_name].try(:first))
+          when :enum, :multienum, :text, :string
+            @obj[real_attribute_name]
+          else
+            Assert.success(
+              false,
+              "Unknown attribute type #{virtual_attribute_type} for attribute: #{virtual_attribute_name}"
+            )
+          end
+
+          attrs[virtual_attribute_name] = [val, virtual_attribute_type]
+        end
+      end
+
+      def deserialize_link(link)
+        if link
+          {
+            # remove possible external prefix for protcol-less urls
+            url: link.url.try(:gsub, /\Aexternal:/, ''),
+            title: link.title,
+            target: link.target,
+            # content service uses destination
+            destination: link.destination_object_id,
+            # rest api uses obj_id
+            obj_id: link.destination_object_id,
+            query: link.query,
+            fragment: link.fragment
+          }
+        end
+      end
+
+      def deserialize_reference(link)
+        if link && link.internal?
+          link.destination_object_id
+        end
+      end
+
+      def deserialize_widget_field(linklist)
+        if !linklist.empty?
+          widgets = linklist.map do |link|
+            widget_id = link.title
+            {widget: widget_id}
+          end
+
+          {list: widgets}
+        end
+      end
+
+      def deserialize_html(html)
+        @link_converter.convert(html)
+      end
+
+      def deserialize_binary(link)
+        if link
+          binary_id = link.title
+          if binary_id.length == 32 && binary_id =~ /0{16,}0*[0-9]+/
+            {id: binary_id}
+          end
+        end
+      end
+
+      def replace_widget_pool(attrs, *args)
+        if (widget_links = @obj[:X_widget_pool])
+
+          resolver = WidgetResolver.new(widget_links, @klass)
+
+          Assert.success(
+            resolver.instance_map.all? {|_, instance| !instance.nil?},
+            "Widget structure in object #{@obj.id} is broken, a widget could not be found"
+          )
+
+          result = Hash[
+            resolver.instance_map.map {|widget_id, widget|
+              [widget_id, WidgetDecorator.new(@klass, widget).as_json(*args)]
+            }
+          ]
+
+          attrs[:_widget_pool] = [result]
+        end
+      end
+    end
+  end
+end