infopark_reactor 1.10.0.beta → 1.11.0.beta2

data/lib/reactor/cm/bridge.rb

@@ -0,0 +1,50 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  module Cm
+    class Bridge
+      # credit goes to Anton
+      def self.login_for(sessionId)
+        old_username = Reactor::Configuration.xml_access[:username]
+        Reactor::Configuration.xml_access[:username] = 'root'
+        begin
+          response = Reactor::Cm::XmlRequest.prepare do |xml|
+            xml.tag!('licenseManager-logins')
+          end.execute!
+          login = nil
+          result = response.xpath('//licenseManager-logins/listitem')
+          result = [result] unless result.kind_of?(Array)
+          result.each do |login_data_element|
+            properties = deserialize_login_data(login_data_element.text)
+            if properties[:sessionId] == sessionId && properties[:interface] == "X"
+              login = properties[:login]
+              break
+            end
+          end
+          login
+        rescue => e
+          Rails.logger.error "Login to CM failed! #{e.class}: #{e.message}"
+          nil
+        ensure
+          Reactor::Configuration.xml_access[:username] = old_username
+        end
+      end
+
+      private
+      def self.deserialize_login_data(serialized_property_list)
+        entry_delimiter = /;\r?\n/
+        no_braces = serialized_property_list[1..(serialized_property_list.rindex(entry_delimiter) - 1)]
+        property_list_lines = no_braces.split(entry_delimiter)
+        property_list_lines.inject(properties = {}) do |map, line|
+          key, value = line.strip.scan(/^([^=]*) = (.*)$/).first
+          if value[0..0] == '"'
+            value = value[1..(value.length - 2)]
+            value.gsub!(/\\(.)/, '\1')
+          end
+          map[key.to_sym] = value
+          map
+        end
+        properties
+      end
+    end
+  end
+end

data/lib/reactor/cm/channel.rb

@@ -0,0 +1,18 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/object_base'
+
+module Reactor
+  module Cm
+    class Channel < ObjectBase
+      # Attribute definitions
+      attribute :name, :except => [:set]
+      attribute :title
+
+      primary_key :name
+
+      def self.create(name)
+        super(name, {:name => name})
+      end
+    end
+  end
+end

data/lib/reactor/cm/editorial_group.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/group'
+
+module Reactor
+
+  module Cm
+    
+    # The EditorialGroup class respects the user management configured in the content manager and
+    # handles all editorial groups. See @Group for further details.
+    class EditorialGroup < Group
+      
+      protected
+
+      # Overwritten method from +Group+.
+      def base_name
+        'groupProxy'
+      end
+
+    end
+    
+  end
+  
+end

data/lib/reactor/cm/group.rb

@@ -0,0 +1,241 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/xml_request'
+require 'reactor/cm/xml_response'
+require 'reactor/cm/xml_request_error'
+require 'reactor/tools/xml_attributes'
+require 'reactor/tools/response_handler/string'
+
+require 'reactor/cm/permissions'
+
+module Reactor
+
+  module Cm
+
+    # The Group class can be used to work with user groups defined or known to the content manager.
+    # It allows you to create, edit and delete groups, handle users and permissions and get the
+    # group meta data. The Group class does not respect the user management defined under
+    # "config/userManagement.xml", but is the basis for class like @EditorialGroup or @LiveGroup
+    # that respect the user management.
+    class Group
+
+      include XmlAttributes
+
+      class << self
+
+        # Method returns true if a group with the given +name+ exists, false otherwise.
+        def exists?(name)
+          object = new(:name => name)
+
+          begin
+            object.send(:get).present?
+          rescue XmlRequestError
+            false
+          end
+        end
+
+        # Returns all known group names as an array of strings.
+        def all(match = '')
+          object = new
+
+          base_name = object.send(:base_name)
+
+          request = XmlRequest.prepare do |xml|
+            xml.where_key_tag!(base_name, 'groupText', match)
+            xml.get_key_tag!(base_name, 'name')
+          end
+
+          begin
+            response = request.execute!
+            groups = ResponseHandler::String.new.get(response, '//group/name/text()')
+
+            groups.is_a?(Array) ? groups : [groups]
+          rescue XmlRequestError
+            []
+          end
+
+        end
+
+        # See @get.
+        def get(name)
+          object = new(:name => name)
+          object.send(:get)
+          object
+        end
+
+        # See @create.
+        def create(attributes = {})
+          object = new(attributes)
+          object.send(:create)
+          object
+        end
+
+      end
+
+      include Permissions
+
+      attribute :name, :except => [:set]
+      attribute :display_title, :name => :displayTitle, :only => [:get]
+      attribute :real_name, :name => :realName
+      attribute :owner
+      attribute :users, :type => :list
+
+      primary_key :name
+
+      # Returns true, if an user with the given +name+ exists, false otherwise.
+      def user?(name)
+        users.include?(name)
+      end
+
+      # Add the given +users+ to the current set of group users.
+      def add_users!(users)
+        users = users.kind_of?(Array) ? users : [users]
+        users = self.users | users
+
+        set_users(users)
+      end
+
+      # Remove the given +users+ from the current set of group users.
+      def remove_users!(users)
+        users = users.kind_of?(Array) ? users : [users]
+        users = self.users - users
+
+        set_users(users)
+      end
+
+      # Set the group users to the given +users+.
+      def set_users!(users)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.set_key_tag!(base_name, self.class.xml_attribute(:users).name, users)
+        end
+
+        request.execute!
+
+        self.users = users
+      end
+
+      # Saves all settable instance attributes to the Content Manager.
+      def save!
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.set_tag!(base_name) do
+            self.class.attributes(:set).each do |name, xml_attribute|
+              value = self.send(name)
+
+              xml.value_tag!(xml_attribute.name, value)
+            end
+          end
+        end
+
+        response = request.execute!
+
+        response.ok?
+      end
+
+      # Deletes the current group instance.
+      def delete!
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.delete_tag!(base_name)
+        end
+
+        response = request.execute!
+
+        response.ok?
+      end
+
+      # As it is not possible to actually rename an existing group, this method creates a new group
+      # with the same attributes but a different name as the current instance and deletes the old
+      # group. The method returns the new group object.
+      def rename!(name)
+        new_attributes =
+        self.class.attributes.inject({}) do |hash, mapping|
+          key, _ = mapping
+
+          hash[key] = self.send(key)
+
+          hash
+        end
+
+        if self.delete!
+          new_attributes[:name] = name
+
+          self.class.create(new_attributes)
+        else
+          false
+        end
+      end
+
+      protected
+
+      # The group base name can either be "group", "groupProxy", or "secondaryGroupProxy". Only the
+      # two proxy group names take the configured user management (config/userManagement.xml) into
+      # account. Use +EditorialGroup+ to work on editorial groups and +LiveGroup+ to work on live
+      # groups.
+      def base_name
+        'group'
+      end
+
+      def initialize(attributes = {})
+        update_attributes(attributes)
+      end
+
+      # Retrieves a single group matching the name set in the current instance.
+      def get
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.get_key_tag!(base_name, self.class.xml_attribute_names)
+        end
+
+        response = request.execute!
+
+        self.class.attributes(:get).each do |name, xml_attribute|
+          value = self.class.response_handler.get(response, xml_attribute)
+
+          set_attribute(name, value)
+        end
+
+        self
+      end
+
+      # Creates a new group and sets all attributes that are settable on create. Other attributes
+      # are ignored and would be overwritten by the final +get+ call.
+      def create
+        request = XmlRequest.prepare do |xml|
+          xml.create_tag!(base_name) do |xml|
+            self.class.attributes(:create).each do |name, xml_attribute|
+              value = self.send(name)
+
+              xml.value_tag!(xml_attribute.name, value) if value.present?
+            end
+          end
+        end
+
+        response = request.execute!
+
+        self.name = self.class.response_handler.get(response, self.class.xml_attribute(:name))
+
+        get
+      end
+
+      private
+
+      def update_attributes(attributes) # :nodoc:
+        self.class.attribute_names.each do |name|
+          value = attributes[name]
+
+          if value.present?
+            set_attribute(name, value)
+          end
+        end
+      end
+
+      def set_attribute(name, value) # :nodoc:
+        self.send("#{name}=", value)
+      end
+
+    end
+
+  end
+
+end

data/lib/reactor/cm/language.rb

@@ -0,0 +1,57 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  module Cm
+    class Language
+      def self.get(username = nil)
+        begin
+          options = {}
+          options = {:login => username} if username
+          request = XmlRequest.prepare do |xml|
+            xml.tag!('userConfig-getTexts', options) do
+              xml.tag!('listitem') do
+                 xml.text!('languages.language')
+               end
+             end
+           end
+          response = request.execute!
+          response.xpath('//listitem').text
+        rescue => e
+          return nil
+        end
+      end
+
+      # FIXME: broken ([011003] Die Klasse '%s' wird nicht unterstützt.)
+      def self.set(*args)
+        username = language = nil
+        raise ArgumentError.new('set requires one or two parameters') unless [1,2].include? args.length
+
+        username, language = *args if args.length == 2
+        language = *args if args.length == 1
+
+        raise ArgumentError.new('language cannot be nil') if language.nil?
+        options = {}
+        options = {:login => username} if username
+
+        begin
+          request = XmlRequest.prepare do |xml|
+            xml.tag!('userConfig.setTexts', options) do
+              xml.tag!('dictitem') do
+                xml.tag!('key') do
+                  xml.text!('languages.language')
+                end
+                xml.tag!('value') do
+                  xml.text!(language)
+                end
+              end
+            end
+          end
+          response = request.execute!
+          response.ok?
+        rescue => e
+          return false
+        end
+      end
+
+    end
+  end
+end

data/lib/reactor/cm/link.rb

@@ -0,0 +1,136 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  module Cm
+    class Link
+      attr_reader :link_id, :dest_obj_id, :dest_url
+      attr_accessor :title, :target, :position
+
+      def self.exists?(id)
+        return !Link.get(id).nil?
+      rescue XmlRequestError => e
+        return false
+      end
+
+      def self.get(id)
+        link = Link.new
+        link.send(:get,id)
+        link
+      end
+
+      def self.create_inside(obj, attr, url, title=nil, target=nil)
+        create(obj.edited_content, attr, url, title, target)
+      end
+
+      def self.create(content, attr, url, title=nil, target=nil)
+        link = Link.new
+        link.send(:create, content, attr, url, title, target)
+        link
+      end
+
+      def is_external?
+        @is_external == true
+      end
+
+      def is_internal?
+        !is_external?
+      end
+
+      def dest_obj_id=(obj_id)
+        @is_external  = false
+        @dest_url     = Obj.get(obj_id).path
+        @dest_obj_id  = obj_id
+      end
+
+      def dest_url=(url)
+        @is_external  = (/^\// =~ url).nil?
+        @dest_obj_id  = Obj.get(url).obj_id unless @is_external
+        @dest_url     = url
+      end
+
+      def save!
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @link_id)
+          xml.set_tag!(base_name) do
+            xml.tag!('target', @target) if @target
+            xml.tag!('title', @title) if @title
+            xml.tag!('destinationUrl', @dest_url) if @dest_url
+            xml.tag!('position', @position) if @position
+          end
+        end
+        response = request.execute!
+      end
+
+      def hash
+        # yes, to_s.to_is is neccesary,
+        # because self.link_id is of type REXML::Text for the most of the time
+        self.link_id.to_s.to_i
+      end
+
+
+      def eql?(other)
+        self.link_id == other.link_id
+      end
+
+      def delete!
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @link_id)
+          xml.tag!("#{base_name}-delete")
+        end
+        response = request.execute!
+      end
+
+      protected
+      def initialize
+      end
+
+      def base_name
+        'link'
+      end
+
+      def get(id)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', id)
+          xml.get_key_tag!(base_name, ['id', 'isExternalLink', 'target', 'title', 'destination', 'destinationUrl', 'position'])
+        end
+        response      = request.execute!
+
+        @link_id      = response.xpath('//id/text()')
+        @is_external  = response.xpath('//isExternalLink/text()') == '1'
+        @target       = response.xpath('//target/text()').presence
+        @title        = response.xpath('//title/text()').presence
+        @dest_obj_id  = response.xpath('//destination/text()').presence
+        @dest_url     = response.xpath('//destinationUrl/text()').presence
+        @position     = response.xpath('//position/text()').presence
+
+        self
+      end
+
+      def create(content, attr, url, title = nil, target = nil)
+        request = XmlRequest.prepare do |xml|
+          xml.create_tag!(base_name) do
+            xml.tag!('attributeName', attr.to_s)
+            xml.tag!('sourceContent', content.to_s)
+            xml.tag!('destinationUrl', url.to_s)
+          end
+        end
+        response = request.execute!
+
+        id = response.xpath('//id/text()')
+        get(id)
+
+        if !title.nil? || !target.nil?
+          request = XmlRequest.prepare do |xml|
+            xml.where_key_tag!(base_name, 'id', id)
+            xml.set_tag!(base_name) do
+              xml.value_tag!('title', title) if title
+              xml.value_tag!('target', target) if target
+            end
+          end
+          response = request.execute!
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/reactor/cm/live_group.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/group'
+
+module Reactor
+
+  module Cm
+
+    # The LiveGroup class respects the user management configured in the content manager and
+    # handles all live groups. See @Group for further details.
+    class LiveGroup < Group
+      
+      protected
+
+      # Overwritten method from +Group+.
+      def base_name
+        'secondaryGroupProxy'
+      end
+
+    end
+    
+  end
+  
+end

data/lib/reactor/cm/log_entry.rb

@@ -0,0 +1,64 @@
+module Reactor
+  module Cm
+    class LogEntry
+      class << self
+        def where(conditions = {})
+          request = XmlRequest.prepare do |xml|
+            where_part(xml, conditions)
+            xml.tag!('logEntry-get') do
+              xml.tag!('logTime')
+              xml.tag!('logText')
+              xml.tag!('logType')
+              xml.tag!('objectId')
+              xml.tag!('receiver')
+              xml.tag!('userLogin')
+            end
+          end
+          response = request.execute!
+          
+          result = []
+          log_entries = response.xpath('//logEntry')
+          log_entries = [log_entries] unless log_entries.kind_of?(Array)
+          log_entries.each do |log_entry_node|
+            dict = {}
+            log_entry_node.each_element do |value_node|
+              if value_node.name == 'logTime'
+                dict[value_node.name] = value_node.elements['isoDateTime'].text.to_s
+              else
+                dict[value_node.name] = value_node.text.to_s
+              end
+            end
+
+            result << dict
+          end
+
+          return result
+        rescue Reactor::Cm::XmlRequestError => e
+          if e.message =~ /#{Regexp.escape('[060001] Es wurde kein Eintrag gefunden.')}/
+            return []
+          else
+            raise e
+          end
+        end
+
+        def delete(conditions)
+          request = XmlRequest.prepare do |xml|
+            where_part(xml, conditions)
+            xml.tag!('logEntry-delete')
+          end
+          response = request.execute!
+          result = response.xpath('//deleteLogEntriesCount').map {|x| x.text.to_s }.first
+        end
+
+        protected
+        def where_part(xml, conditions)
+          xml.tag!('logEntry-where') do
+            conditions.each do |key, value|
+              xml.tag!(key.to_s, value.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reactor/cm/missing_credentials.rb

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+  module Cm
+    class MissingCredentials < StandardError
+      def initialize ; super("CM access credentials are missing. Check your configuration or supplied credentials.") ; end
+    end
+  end
+end