infopark_reactor_migrations 1.5.1

data/lib/reactor/cm/group.rb

@@ -0,0 +1,270 @@
+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'
+
+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
+
+      attribute :name, :except => [:set]
+      attribute :display_title, :name => :displayTitle, :only => [:get]
+      attribute :real_name, :name => :realName
+      attribute :owner
+      attribute :users, :type => :list
+      attribute :global_permissions, :name => :globalPermissions, :type => :list
+
+      primary_key :name
+
+      # Returns true, if a global permission with the given +name+ exists, false otherwise.
+      def global_permission?(name)
+        self.global_permissions.include?(name.to_s)
+      end
+
+      # Add the given +permissions+ to the current set of group permissions.
+      def grant_global_permissions!(permissions)
+        permissions = permissions.kind_of?(Array) ? permissions : [permissions]
+        permissions = self.global_permissions | permissions
+
+        set_global_permissions!(permissions)
+      end
+
+      # Take away the given +permissions+ from the current set of group permissions.
+      def revoke_global_permissions!(permissions)
+        permissions = permissions.kind_of?(Array) ? permissions : [permissions]
+        permissions = self.global_permissions - permissions
+
+        set_global_permissions(permissions)
+      end
+
+      # Set the group permissions to the given +permissions+.
+      def set_global_permissions!(permissions)
+        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(:global_permissions).name, permissions)
+        end
+
+        request.execute!
+
+        self.global_permissions = permissions
+      end
+
+      # 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,56 @@
+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,132 @@
+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)
+        create(obj.edited_content, attr, url, title)
+      end
+
+      def self.create(content, attr, url, title=nil)
+        link = Link.new
+        link.send(:create, content, attr, url, title)
+        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)
+        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?
+          request = XmlRequest.prepare do |xml|
+            xml.where_key_tag!(base_name, 'id', id)
+            xml.set_key_tag!(base_name, 'title', title)
+          end
+          response = request.execute!
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/reactor/cm/live_group.rb

@@ -0,0 +1,22 @@
+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/missing_credentials.rb

@@ -0,0 +1,7 @@
+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