infopark_reactor 1.10.0.beta → 1.11.0.beta2

data/lib/reactor/cm/xml_request.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+require 'net/http'
+require 'reactor/cm/xml_response'
+require 'reactor/cm/xml_single_request_error'
+require 'reactor/cm/xml_markup'
+require 'reactor/tools/smart_xml_logger'
+
+module Reactor
+  module Cm
+
+    if Rails.env.development? && false
+      #LOGGER = SmartXmlLogger.new(Rails.logger, :debug)
+      LOGGER = SmartXmlLogger.new(Kernel, :puts)
+    else
+      LOGGER = SmartXmlLogger.new(nil)   # turn off logging
+    end
+    LOGGER.configure(:request, :xpath => 'cm-payload/cm-request/*', :start_indent => 2)
+    LOGGER.configure(:response, :xpath => 'cm-payload/cm-response/*', :start_indent => 2)
+
+    class XmlRequest
+
+      def self.token(login, instance_secret)
+        Digest::MD5.hexdigest(login + instance_secret)
+      end
+
+      def self.prepare
+        access = Configuration::xml_access
+        sanity_check(access)
+        xml = XmlMarkup.new
+        ret = nil
+        xml.instruct!
+        ret = xml.tag!('cm-payload', 'payload-id' =>'abcabc', 'timestamp' => Time.now.getutc.strftime('%Y%m%d%H%M%S'), 'version' => '6.7.3') do
+          xml.tag!('cm-header') do
+            xml.tag!('cm-sender', 'sender-id' => access[:id], 'name' => "ruby-simple-client")
+            xml.tag!('cm-authentication', 'login' => access[:username], 'token' => token(access[:username],access[:secret]))
+          end
+          id = self.generate_id
+          xml.tag!('cm-request', 'request-id' => id) do |xml2|
+            yield xml2 if block_given?
+          end
+        end
+        XmlRequest.new(ret)
+      end
+
+      def execute!
+        access = Configuration::xml_access
+        payload = @xml
+
+        res = Net::HTTP.new(access[:host], access[:port]).start do |http|
+          req = Net::HTTP::Post.new('/xml')
+          Reactor::Cm::LOGGER.log('REQUEST:')
+          Reactor::Cm::LOGGER.log_xml(:request, payload)
+          req.body = payload
+          http.request(req)
+        end
+        Reactor::Cm::LOGGER.log('RESPONSE:')
+        Reactor::Cm::LOGGER.log_xml(:response, res.body)
+        response = XmlResponse.new(res.body)
+        raise XmlSingleRequestError, response unless response.ok?
+        response
+      end
+
+      class << self
+        protected
+
+        def generate_id
+          rand(10000)
+        end
+
+        def sanity_check(access)
+          raise Reactor::Cm::MissingCredentials if access[:username].nil? || access[:username].empty?
+        end
+      end
+
+      protected
+
+      def initialize(xml)
+        @xml = xml
+      end
+
+    end
+  end
+end

data/lib/reactor/cm/xml_request_error.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  module Cm
+    class XmlRequestError < StandardError
+      def phrase
+        self.message
+      end
+
+    end
+  end
+end

data/lib/reactor/cm/xml_response.rb

@@ -0,0 +1,43 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/tools/response_handler/xml_attribute'
+require 'rexml/document'
+
+module Reactor
+
+  module Cm
+
+    class XmlResponse
+
+      attr_reader :xml
+      attr_reader :xml_str
+
+      def initialize(xml)
+        @xml_str = xml
+        @xml = REXML::Document.new(xml)
+        @handler = Reactor::ResponseHandler::XmlAttribute.new
+      end
+
+      def xpath(expr)
+        arr = REXML::XPath.match(@xml, expr)
+
+        return arr.first if arr.length == 1
+        return arr
+      end
+
+      def ok?
+        xp = xpath('//cm-code')
+
+        if xp.is_a?(Array)
+          codes = xp.map { |result| result.attribute('numeric').value }.uniq
+
+          return codes.size == 1 && codes.first == '200'
+        end
+
+        xp.attribute('numeric').value == '200'
+      end
+
+    end
+
+  end
+
+end

data/lib/reactor/cm/xml_single_request_error.rb

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/xml_request_error'
+
+module Reactor
+  module Cm
+    class XmlSingleRequestError < XmlRequestError
+      def initialize(response)
+        @response = response
+        super(phrase)
+      end
+
+      def phrase
+        result = @response.xpath('//phrase')
+        result = [result] unless result.kind_of?(Array)
+
+        result.map(&:to_s).join("\n")
+      end
+
+    end
+  end
+end

data/lib/reactor/configuration.rb

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  class Configuration
+    class << self
+      attr_accessor :xml_access
+    end
+  end
+end

data/lib/{engine.rb → reactor/engine.rb}

@@ -2,8 +2,23 @@
 module Reactor
 
   class Engine < Rails::Engine
+    rake_tasks do
+      load "tasks/cm_migrate.rake"
+      load "tasks/cm_seeds.rake"
+    end
+
+    initializer "reactor.upgrade" do
+      if Gem::Specification.find_all_by_name('infopark_reactor_migrations').any? || Gem::Specification.find_all_by_name('infopark_rails_connector_meta').any?
+        raise "Please remove 'infopark_reactor_migrations' and 'infopark_rails_connector_meta' from your Gemfile. They are deprecated and no longer needed."
+      end
+    end
+
+    initializer "reactor.rsession" do |app|
+      if app.config.action_dispatch.cookies_serializer && app.config.action_dispatch.cookies_serializer != :marshal
+        Rails.logger.info "Cookie session serializer #{app.config.action_dispatch.cookies_serializer} unsupported. Enforcing :marshal instead."
+        app.config.action_dispatch.cookies_serializer = :marshal
+      end
 
-    initializer "reactor.rsession" do
       # FIXME: extract !
       AbstractController::Base.__send__(:define_method, :rsession) do
         self.session[:rsession] ||= Reactor::Session.instance

data/lib/reactor/legacy.rb

@@ -46,9 +46,9 @@ module Reactor
 
       def obj_from_anything(anything)
         case anything
-        when Fixnum then Obj.find(anything)
-        when String then Obj.find_by_path(anything)
-        when Obj then anything
+        when Fixnum then RailsConnector::AbstractObj.find(anything)
+        when String then RailsConnector::AbstractObj.find_by_path(anything)
+        when RailsConnector::AbstractObj then anything
         else raise ArgumentError, "Link target must Fixnum, String or Obj, but was #{anything.class}."
         end
       end

data/lib/reactor/link/temporary_link.rb

@@ -4,6 +4,7 @@ module Reactor
     class TemporaryLink
       attr_reader   :url
       attr_accessor :title
+      attr_accessor :target
 
       def external? ; raise TypeError, "This link needs to be persisted to gain any meaningful information" ; end
       def internal? ; false ; end
@@ -14,17 +15,20 @@ module Reactor
         case anything
         when Hash
           link_data = anything
+        when Fixnum
+          link_data[:url] = RailsConnector::AbstractObj.find(anything).path
         else
-          link_data[:target] = anything
+          link_data[:url] = anything
         end
 
-        self.url    = link_data[:target] || link_data[:url] || link_data[:destination_object]
+        self.url    = link_data[:url] || link_data[:destination_object]
+        self.target = link_data[:target] if link_data.key?(:target)
         self.title  = link_data[:title] if link_data.key?(:title)
       end
 
       def url=(some_target)
         @url = case some_target
-        when Obj
+        when RailsConnector::AbstractObj
           @destination_object = some_target
           some_target.path
         else
@@ -33,7 +37,7 @@ module Reactor
       end
 
       def destination_object
-        @destination_object ||= Obj.find_by_path(url)
+        @destination_object ||= RailsConnector::AbstractObj.find_by_path(url)
       end
 
       def id

data/lib/reactor/migration.rb

@@ -0,0 +1,87 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/plans/create_obj'
+require 'reactor/plans/delete_obj'
+require 'reactor/plans/update_obj'
+require 'reactor/plans/create_obj_class'
+require 'reactor/plans/delete_obj_class'
+require 'reactor/plans/update_obj_class'
+require 'reactor/plans/rename_obj_class'
+require 'reactor/plans/create_attribute'
+require 'reactor/plans/delete_attribute'
+require 'reactor/plans/update_attribute'
+require 'reactor/plans/create_group'
+require 'reactor/plans/update_group'
+require 'reactor/plans/delete_group'
+require 'reactor/plans/rename_group'
+require 'reactor/plans/create_channel'
+require 'reactor/plans/delete_channel'
+
+module Reactor
+  class Migration
+    METHODS = {
+      :create_obj => Plans::CreateObj,
+      :delete_obj => Plans::DeleteObj,
+      :update_obj => Plans::UpdateObj,
+      :create_class => Plans::CreateObjClass,
+      :delete_class => Plans::DeleteObjClass,
+      :update_class => Plans::UpdateObjClass,
+      :rename_class => Plans::RenameObjClass,
+      :create_attribute => Plans::CreateAttribute,
+      :delete_attribute => Plans::DeleteAttribute,
+      :update_attribute => Plans::UpdateAttribute,
+      :create_group => Plans::CreateGroup,
+      :delete_group => Plans::DeleteGroup,
+      :update_group => Plans::UpdateGroup,
+      :rename_group => Plans::RenameGroup,
+      :create_channel => Plans::CreateChannel,
+      :delete_channel => Plans::DeleteChannel
+    }
+
+    def self.method_missing(name, *args, &block)
+      if METHODS.key? name.to_sym then
+        instance = init(name,*args)
+        plan(instance,&block)
+        prepare(instance)
+        migrate(instance)
+      else
+        super(name, *args, &block)
+      end
+    end
+
+    def self.respond_to?(name)
+      METHODS.key?(name.to_sym) || super(name)
+    end
+
+    def self.contains(*args)
+      @contained ||= []
+      args.flatten.each do |arg|
+        migration_num = arg.to_i.to_s
+        @contained << migration_num
+      end
+    end
+
+    def self.contained
+      @contained || []
+    end
+
+    protected
+    def self.init(name,*args)
+      METHODS[name.to_sym].new(*args)
+    end
+
+    def self.plan(instance,&block)
+      instance.instance_eval(&block) if block_given?
+    end
+
+    def self.prepare(instance)
+      instance.prepare! if instance.respond_to? :prepare!
+    end
+
+    def self.migrate(instance)
+      instance.migrate!
+    end
+
+    private
+    def initialize ; end
+  end
+end

data/lib/reactor/permission.rb

@@ -98,8 +98,8 @@ module Reactor
       end
 
       def ensure_create_permission_granted(obj_id)
-        raise RuntimeError, "Permission check for object with id=#{obj_id.inspect} which does not exist" unless Obj.exists?(obj_id)
-        raise Reactor::NotPermitted, 'Obj lacks neccessary permissions for creation' unless Obj.find(obj_id).permission.create_children?
+        raise RuntimeError, "Permission check for object with id=#{obj_id.inspect} which does not exist" unless RailsConnector::AbstractObj.exists?(obj_id)
+        raise Reactor::NotPermitted, 'Obj lacks neccessary permissions for creation' unless RailsConnector::AbstractObj.find(obj_id).permission.create_children?
         return true
       end
 

data/lib/reactor/persistence.rb

@@ -177,12 +177,12 @@ module Reactor
       # any other reload methods (neither from RailsConnector nor from ActiveRecord)
       # but tries to mimmic their behaviour.
       def reload(options = nil)
-        Obj.uncached do
+        RailsConnector::AbstractObj.uncached do
           #super # Throws RecordNotFound when changing obj_class
           # AR reload
           clear_aggregation_cache
           clear_association_cache
-          fresh_object = Obj.find(self.id, options)
+          fresh_object = RailsConnector::AbstractObj.find(self.id, options)
           @attributes = fresh_object.instance_variable_get('@attributes')
           @attributes_cache = {}
           # RC reload
@@ -231,7 +231,7 @@ module Reactor
             super(attributes)
           end
         end
-      elsif Reactor.rails3_1? || Reactor.rails3_2? || Reactor.rails4_0?
+      elsif Reactor.rails3_1? || Reactor.rails3_2? || Reactor.rails4_0? || Reactor.rails4_1?
         # It should excactly match ActiveRecord::Base.new in it's behavior
         # @see ActiveRecord::Base.new
         def initialize(attributes = nil, options={}, &block)
@@ -326,7 +326,7 @@ module Reactor
         new_links = {}.tap do |result|
           linklists.map do |field|
             result[field] = self.__read_link(field).map do |l|
-              {:link_id => l.id, :title => l.title, :destination_url => (l.internal? ? l.destination_object.path : l.url)} 
+              {:link_id => l.id, :title => l.title, :destination_url => (l.internal? ? l.destination_object.path : l.url), :target => l.target}
             end
           end
         end
@@ -339,7 +339,7 @@ module Reactor
           links_to_remove.clear
           links_to_set.clear
 
-          copy = Obj.find(self.id)
+          copy = RailsConnector::AbstractObj.uncached { RailsConnector::AbstractObj.find(self.id) }
 
           linklists.each do |linklist|
             original_link_ids = copy.__read_link(linklist).original_link_ids
@@ -371,6 +371,8 @@ module Reactor
             end
           end
         end
+
+        self.class.connection.clear_query_cache
       end
 
       def __read_link(name)
@@ -385,7 +387,7 @@ module Reactor
       # @param [true, false] recursive set to true to also copy the underlying subtree
       # @param [String] new_name gives the object new name
       def copy(new_parent, recursive = false, new_name = nil)
-        self.id = crul_obj.copy(Obj.path_from_anything(new_parent), recursive, new_name)
+        self.id = crul_obj.copy(RailsConnector::AbstractObj.path_from_anything(new_parent), recursive, new_name)
         #self.reload
         resolve_refs #?
         self.id
@@ -412,8 +414,8 @@ module Reactor
         end
       end
 
-      if Reactor.rails4_0?
-        if Reactor.rails4_0_ge6?
+      if Reactor.rails4_0? || Reactor.rails4_1?
+        if Reactor.rails4_0_ge6? || Reactor.rails4_1?
           alias_method :_create_record, :create
         else
           alias_method :create_record, :create
@@ -428,8 +430,8 @@ module Reactor
          end
       end
 
-      if Reactor.rails4_0?
-        if Reactor.rails4_0_ge6?
+      if Reactor.rails4_0? || Reactor.rails4_1?
+        if Reactor.rails4_0_ge6? || Reactor.rails4_1?
           alias_method :_update_record, :update
         else
           alias_method :update_record, :update
@@ -482,7 +484,7 @@ module Reactor
         new_name
       end
 
-      if Reactor.rails4_0?
+      if Reactor.rails4_0? || Reactor.rails4_1?
         # Detect the subclass from the inheritance column of attrs. If the inheritance column value
         # is not self or a valid subclass, raises ActiveRecord::SubclassNotFound
         # If this is a StrongParameters hash, and access to inheritance_column is not permitted,
@@ -503,7 +505,7 @@ module Reactor
           end
         end
 
-        if Reactor.rails4_0_ge6?
+        if Reactor.rails4_0_ge6? || Reactor.rails4_1?
           alias_method :subclass_from_attributes, :subclass_from_attrs
           remove_method :subclass_from_attrs
         end

data/lib/reactor/plans/common_attribute.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  module Plans
+    class CommonAttribute
+      include Prepared
+
+      ALLOWED_PARAMS = [:callback, :helpText, :maxSize, :minSize,
+        :title, :values]
+
+      def initialize
+        @params = {}
+      end
+
+      def set(key,value)
+        @params[key.to_sym] = value
+      end
+
+      def migrate!
+        raise "#{self.class.name} did not implement migrate!"
+      end
+
+      protected
+      def prepare_params!(attribute=nil)
+        @params.keys.each{|k| error("unknown parameter: #{k}") unless ALLOWED_PARAMS.include? k}
+      end
+
+      def migrate_params!(attribute)
+        @params.each{|k,v|attribute.set(k,v)}
+        attribute.save!
+      end
+    end
+  end
+end

data/lib/reactor/plans/common_channel.rb

@@ -0,0 +1,32 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  module Plans
+    class CommonChannel
+      include Prepared
+
+      ALLOWED_PARAMS = [:title]
+
+      def initialize
+        @params = {}
+      end
+
+      def set(key,value)
+        @params[key.to_sym] = value
+      end
+
+      def migrate!
+        raise "#{self.class.name} did not implement migrate!"
+      end
+
+      protected
+      def prepare_params!(channel=nil)
+        @params.keys.each{|k| error("unknown parameter: #{k}") unless ALLOWED_PARAMS.include? k}
+      end
+
+      def migrate_params!(channel)
+        @params.each{|k,v|channel.send(:"#{k}=",v)}
+        channel.save!
+      end
+    end
+  end
+end

data/lib/reactor/plans/common_group.rb

@@ -0,0 +1,45 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+
+  module Plans
+
+    class CommonGroup
+
+      include Prepared
+
+      ALLOWED_PARAMS = [
+        :users, 
+        :global_permissions, 
+        :real_name, 
+        :owner,
+      ]
+
+      def initialize
+        @params = {}
+      end
+
+      def set(key, value)
+        @params[key.to_sym] = value
+      end
+
+      def migrate!
+        raise "#{self.class.name} did not implement migrate!"
+      end
+
+      protected
+
+      def prepare_params!(group = nil)
+        @params.keys.each { |key| error("unknown parameter: #{key}") unless ALLOWED_PARAMS.include?(key) }
+      end
+
+      def migrate_params!(group)
+        @params.each { |key, value| group.send("#{key}=", value) }
+
+        group.save!
+      end
+
+    end
+
+  end
+
+end

data/lib/reactor/plans/common_obj_class.rb

@@ -0,0 +1,70 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  module Plans
+    class CommonObjClass
+      include Prepared
+
+      ALLOWED_PARAMS = [:completionCheck, :isEnabled, :recordSetCallback, :title,
+        :validContentTypes, :workflowModification]
+
+      def initialize
+        @take_attrs = []
+        @drop_attrs = []
+        @mandatory_attrs = []
+        @mandatory_drop_attrs = []
+        @preset_attrs = {}
+        @params = {}
+        @params_options = {}
+      end
+
+      def set(key, value, options={})
+        @params_options[key.to_sym] = options
+        @params[key.to_sym] = value
+      end
+
+      def take(attr_name, opts={})
+        attr_name = attr_name.to_s
+        @take_attrs << attr_name
+        @drop_attrs.delete(attr_name)
+        @mandatory_attrs << attr_name if opts[:mandatory] == true
+        @mandatory_drop_attrs << attr_name if opts[:mandatory] == false
+        @preset_attrs[attr_name] = opts[:preset] if opts.key? :preset
+      end
+
+      def drop(attr_name, opts={})
+        attr_name = attr_name.to_s
+        @drop_attrs << attr_name
+        @take_attrs.delete(attr_name)
+        @mandatory_attrs.delete(attr_name)
+        @preset_attrs.delete(attr_name)
+      end
+
+      def migrate!
+        raise "#{self.class.name} did not implement migrate!"
+      end
+
+      protected
+      def prepare_attrs!(klass=nil)
+        @take_attrs.each do |attr|
+          error("attribute doesn't exist #{attr}") unless Reactor::Cm::Attribute.exists?(attr)
+        end
+      end
+
+      def prepare_params!(klass=nil)
+        @params.keys.each{|k| error("unknown parameter: #{k}") unless ALLOWED_PARAMS.include? k}
+      end
+
+      def migrate_attrs!(klass)
+        attrs = (klass.attributes + @take_attrs).uniq - @drop_attrs
+        klass.attributes = attrs
+        klass.mandatory_attributes = ((klass.mandatory_attributes + @mandatory_attrs).uniq - @drop_attrs - @mandatory_drop_attrs)
+      end
+
+      def migrate_params!(klass)
+        @params.each{|k,v|klass.set(k,v,@params_options[k])}
+        klass.preset_attributes.merge(@preset_attrs).each{|k,v|klass.preset(k,v)}
+        klass.save!
+      end
+    end
+  end
+end

data/lib/reactor/plans/create_attribute.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/plans/common_attribute'
+
+module Reactor
+  module Plans
+    class CreateAttribute < CommonAttribute
+      def initialize(*args)
+        super()
+        (name, type), options = separate_arguments(*args)
+        @name = name || options[:name]
+        @type = type || options[:type]
+        # Default values for attributes:
+        # isSearchableInCM: false
+        # isSearchableInTE: false
+        set(:isSearchableInCM, 0)
+        set(:isSearchableInTE, 0)
+      end
+
+      def prepare!
+        error("name ist nil") if @name.nil?
+        error("type is nil") if @type.nil?
+        # TODO: Type check
+        prepare_params!(nil)
+      end
+
+      def migrate!
+        attrib = Reactor::Cm::Attribute.create(@name, @type)
+        migrate_params!(attrib)
+      end
+
+    end
+  end
+end

data/lib/reactor/plans/create_channel.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/channel'
+require 'reactor/plans/common_channel'
+
+module Reactor
+  module Plans
+    class CreateChannel < CommonChannel
+      def initialize(*args)
+        super()
+        (name, x), options = separate_arguments(*args)
+        @name = name || options[:name]
+      end
+
+      def prepare!
+        error("name is nil") if @name.nil?
+      end
+
+      def migrate!
+        channel = Reactor::Cm::Channel.create(@name)
+        migrate_params!(channel)
+      end
+    end
+  end
+end