infopark_reactor 1.10.0.beta → 1.11.0.beta2

data/lib/reactor/cm/obj_class.rb

@@ -0,0 +1,187 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/xml_request'
+require 'reactor/cm/xml_response'
+require 'reactor/cm/xml_request_error'
+
+module Reactor
+  module Cm
+    class ObjClass
+      def self.exists?(name)
+        klass = ObjClass.new
+        begin
+          return klass.send(:get, name).ok?
+        rescue
+          return false
+        end
+      end
+
+      def self.create(name, type)
+        klass = ObjClass.new
+        klass.send(:create,name, type)
+        klass
+      end
+
+      def self.get(name)
+        klass = ObjClass.new
+        klass.send(:get, name)
+        klass
+      end
+
+      def self.rename(current_name, new_name)
+        request = XmlRequest.prepare do |xml|
+          xml.tag!('objClass-where') do
+            xml.tag!('name', current_name)
+          end
+          xml.tag!('objClass-set') do
+            xml.tag!('name', new_name)
+          end
+        end
+        request.execute!
+      end
+
+      def set(key, value, options={})
+        @params_options[key.to_sym] = (!options.nil? && !options.empty? && options) || {}
+        @params[key.to_sym] = value
+      end
+
+      def preset(key, value)
+        @preset[key] = value
+      end
+
+      def preset_attributes
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'name', @name)
+          xml.get_key_tag!(base_name, 'presetAttributes')
+        end
+        response = request.execute!
+        result = response.xpath('//dictitem')
+        result = [result] unless result.kind_of?(Array)
+        result.map do |dictitem|
+          key = dictitem.children.detect {|c| c.name == 'key'}.text
+          value = dictitem.children.detect {|c| c.name == 'value'}.text
+          {key => value}
+        end.inject({}, &:merge)
+      end
+
+
+      def save!
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'name', @name)
+          xml.set_tag!(base_name) do
+            @params.each do |key, value|
+              if @params_options[key][:cdata]
+                xml.tag!(key.to_s) do
+                  xml.cdata!(value)
+                end
+              else
+                xml.value_tag!(key.to_s, value)
+              end
+            end
+            unless @preset.empty?
+              all_preset = (preset_attributes.merge(@preset))
+              xml.tag!('presetAttributes') do
+                @preset.each do |key, value|
+                  xml.tag!('dictitem') do
+                    xml.tag!('key') do
+                      xml.text!(key.to_s)
+                    end
+                    xml.tag!('value') do
+                      xml.text!(value.to_s)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        response = request.execute!
+      end
+
+      def has_attribute?(attr_name)
+        attributes.include? attr_name
+      end
+
+      def attributes
+        __attributes_get('attributes')
+      end
+
+      def attributes=(attr_arr)
+        __attributes_set('attributes', attr_arr)
+      end
+
+      def mandatory_attributes
+        __attributes_get('mandatoryAttributes')
+      end
+
+      def mandatory_attributes=(attr_arr)
+        __attributes_set('mandatoryAttributes', attr_arr)
+      end
+
+      def delete!
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'name', @name)
+          xml.tag!("#{base_name}-delete")
+        end
+        response = request.execute!
+      end
+
+      protected
+      def base_name
+        'objClass'
+      end
+
+      def initialize(name=nil)
+        @name = name
+        @params = {}
+        @params_options = {}
+        @preset = {}
+      end
+
+      def get(name)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'name', name)
+          xml.get_key_tag!(base_name, 'name')
+        end
+        response = request.execute!
+        @name = name
+        response
+      end
+
+      def create(name, type)
+        request = XmlRequest.prepare do |xml|
+          xml.create_tag!(base_name) do |xml|
+            xml.tag!('name') do
+              xml.text!(name)
+            end
+            xml.tag!('objType') do
+              xml.text!(type)
+            end
+          end
+        end
+        response = request.execute!
+        @name = name
+        response
+      end
+
+      private
+      def __attributes_get(field)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'name', @name)
+          xml.get_key_tag!(base_name, field)
+        end
+        response = request.execute!
+        items = response.xpath("//listitem/text()")
+        return [items.to_s] unless items.kind_of?(Array)
+        items.map(&:to_s)
+      end
+
+      def __attributes_set(field, attr_arr)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'name', @name)
+          xml.set_key_tag!(base_name, field, attr_arr)
+        end
+        response = request.execute!
+      end
+    end
+  end
+end

data/lib/reactor/cm/object_base.rb

@@ -0,0 +1,165 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/tools/xml_attributes'
+
+module Reactor
+  module Cm
+    class ObjectBase
+      def self.inherited(subclass)
+        # dynamic binding is required, otherwise class attributes
+        # aren't stored in the correct class
+        subclass.send(:include, Reactor::XmlAttributes)
+      end
+
+      # Default base_name is lowercased class name (without namespaces)
+      def self.base_name
+        self.name.split('::').last.downcase
+      end
+
+      def base_name
+        self.class.base_name
+      end
+
+      # Sets the base name for the object. Use it when inheriting the class, for example:
+      #     class Obj < ObjectBase
+      #       set_base_name 'obj'
+      #     end
+      def self.set_base_name(base_name_value)
+         # we us evaluation of a string in this case, because
+        # define_method cannot handle default values
+        self.class_eval <<-EOH
+          def self.base_name
+            '#{base_name_value}'
+          end
+        EOH
+      end
+
+      private_class_method :new
+      # Constructor of this class should never be called directly.
+      # Use class methods .get and .create instead (as well as helper method .exists?)
+      def initialize(pk_val)
+        primary_key_value_set(pk_val)
+      end
+
+      # Reloads the data from CM. Fetches all defined attributes.
+      def reload
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, primary_key, primary_key_value)
+          xml.get_key_tag!(base_name, self.class.xml_attribute_names)
+        end
+
+        response = request.execute!
+
+        self.class.attributes.each do |attr_name, attr_def|
+          self.send(:"#{attr_name}=", self.class.response_handler.get(response, attr_def))
+        end
+
+        self
+      end
+
+      # Saves all settable instance attributes to the Content Manager.
+      def save!
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, primary_key, primary_key_value)
+          xml.set_tag!(base_name) do
+            self.class.attributes(:set).each do |name, xml_attribute|
+              value = self.send(name)
+              serialize_attribute_to_xml(xml, xml_attribute, value)
+            end
+          end
+        end
+
+        response = request.execute!
+
+        response.ok?
+      end
+
+      # Alias for #save!
+      def save ; save! ; end
+
+      # Proxy method. @see .delete!(login)
+      def delete!
+        self.class.delete!(self.primary_key_value)
+      end
+
+      def serialize_attribute_to_xml(xml, xml_attribute, value)
+        self.class.serialize_attribute_to_xml(xml, xml_attribute, value)
+      end
+
+      def self.serialize_attribute_to_xml(xml, xml_attribute, value)
+        xml.value_tag!(xml_attribute.name, value)
+      end
+
+      # Returns true when object with given primary key exists in CM
+      # Returns false otherwise
+      def self.exists?(pk_val)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, primary_key, pk_val)
+          xml.get_key_tag!(base_name, primary_key)
+        end
+
+        response = request.execute!
+
+        return response.ok?
+
+      rescue XmlRequestError => e
+        return false
+      end
+
+      # Returns an instance of the class for object with given primary key
+      # XmlRequestError will be raised when error occurs (for example
+      # when there is no object with given primary key)
+      def self.get(pk_val)
+        obj = new(pk_val)
+        obj.reload
+        obj
+      end
+
+      # Removes object with given pk from CM.
+      # Returns true on success, raises XmlRequestError on error
+      def self.delete!(pk_val)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, primary_key, pk_val)
+          xml.delete_tag!(base_name)
+        end
+
+        return request.execute!.ok?
+      end
+      # Alias for #delete!
+      def delete ; delete! ; end
+
+      class << self
+        # This method should never be called directly. It should always be overriden!
+        # pk_value is the value of primary key, it should have its double in attributes hash
+        # attributes is a hash of attributes set on creation {:name => 'value'}
+        protected
+        def create(pk_value, attributes)
+          request = XmlRequest.prepare do |xml|
+            xml.create_tag!(base_name) do
+              attributes.each do |attr_name, attr_value|
+                #serialize_attribute_to_xml(xml, xml_attribute, value)
+                xml.value_tag!(attr_name, attr_value)
+              end
+            end
+          end
+
+          response = request.execute!
+
+          return get(pk_value)
+        end
+      end
+
+      protected
+      def primary_key
+        self.class.primary_key
+      end
+
+      def primary_key_value
+        instance_variable_get("@#{self.primary_key}")
+      end
+
+      def primary_key_value_set(value)
+        instance_variable_set("@#{self.primary_key}", value)
+      end
+    end
+  end
+end

data/lib/reactor/cm/permissions.rb

@@ -0,0 +1,44 @@
+module Reactor
+  module Cm
+    module Permissions
+      def self.included(base)
+        base.instance_eval do
+          attribute :global_permissions, :name => :globalPermissions, :type => :list
+        end
+      end
+
+      # 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
+    end
+  end
+end

data/lib/reactor/cm/user.rb

@@ -0,0 +1,139 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/object_base'
+require 'reactor/configuration'
+require 'reactor/cm/language'
+require 'reactor/tools/xml_attributes'
+
+require 'reactor/cm/permissions'
+
+module Reactor
+
+  module Cm
+
+    class User
+
+      class Internal < Reactor::Cm::ObjectBase
+        set_base_name 'user'
+
+        # Attribute definitions
+        attribute :login,         :except => [:set]
+        attribute :super_user,    :except => [:set], :name => :isSuperUser
+        attribute :default_group, :name => :defaultGroup
+        attribute :groups,        :type => :list
+        attribute :real_name,     :name => :realName
+
+        include Permissions
+
+        def name
+          self.login
+        end
+
+        def change_password(new_password)
+          request = XmlRequest.prepare do |xml|
+            xml.where_key_tag!(base_name, primary_key, primary_key_value)
+            xml.set_tag!(base_name) do
+              xml.tag!('password', :verifyNewPassword => new_password) do
+                xml.text!(new_password)
+              end
+            end
+          end
+
+          response = request.execute!
+
+          response.ok?
+        end
+
+        def has_password?(password)
+          ::Reactor::Cm::User.new(self.login).has_password?(password)
+        end
+
+        primary_key :login
+
+        # Returns true if user is root, false otherwise
+        def super_user?
+          super_user == '1'
+        end
+
+        # Creates a user with given login and sets its default group
+        # Returns instance of the class for user with given login
+       def self.create(login, default_group)
+          super(login, {:login => login, :defaultGroup => default_group})
+        end
+
+      end
+
+      include XmlAttributes
+
+      attribute :name
+      attribute :groups, :type => :list
+      attribute :global_permissions, :name => :globalPermissions, :type => :list
+
+
+      primary_key 'login'
+
+      def initialize(name)
+        @name = name
+      end
+
+      def has_password?(password)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.get_tag!(base_name) do |xml3|
+            xml3.tag!('hasPassword', :password => password)
+          end
+        end
+        response = request.execute!
+        response.xpath('//hasPassword/text()') == '1'
+      end
+
+      def is_root?
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.get_key_tag!(base_name, 'isSuperUser')
+        end
+
+        response = request.execute!
+
+        response.xpath('//isSuperUser/text()') == '1'
+      end
+
+      def language
+        Reactor::Cm::Language.get(self.name)
+      end
+
+      def global_permissions
+        xml_attribute = self.class.xml_attribute(:global_permissions)
+
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.get_key_tag!(base_name, xml_attribute.name)
+        end
+
+        response = request.execute!
+
+        self.class.response_handler.get(response, xml_attribute)
+      end
+
+      def groups
+        xml_attribute = self.class.xml_attribute(:groups)
+
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, self.class.primary_key, self.name)
+          xml.get_key_tag!(base_name, xml_attribute.name)
+        end
+
+        response = request.execute!
+
+        self.class.response_handler.get(response, xml_attribute)
+      end
+
+      protected
+      def base_name
+        'userProxy'
+      end
+
+    end
+
+  end
+
+end

data/lib/reactor/cm/workflow.rb

@@ -0,0 +1,41 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/object_base'
+
+module Reactor
+  module Cm
+    class Workflow < ObjectBase
+      # Attribute definitions
+      attribute :name, :except => [:set]
+      attribute :title
+      attribute :is_enabled, :name => :isEnabled
+      attribute :edit_groups, :name => :editGroups, :type => :list
+      attribute :mutiple_signatures, :name => :allowsMultipleSignatures
+      # This attribute should be used as follows:
+      # workflow.signatures = [{:attribute => 'mySigAttr', :group => 'myGroup'},{:attribute => 'mySigAttr', :group => 'myOtherGroup'}]
+      attribute :signatures, :name => :signatureDefs, :type => :signaturelist
+
+      primary_key :name
+
+      # Creates a workflow with given name. A list of edit groups
+      # may also be specified - otherwise it defaults to empty list
+      def self.create(name, edit_groups = [])
+        super(name, {:name => name, :editGroups => edit_groups})
+      end
+
+      def self.serialize_attribute_to_xml(xml, xml_attribute, value)
+        if xml_attribute.name.to_sym == :signatureDefs
+          xml.tag!('signatureDefs') do
+            (value || []).each do |hash|
+              xml.tag!('listitem') do
+                xml.tag!('listitem', hash[:attribute])
+                xml.tag!('listitem', hash[:group])
+              end
+            end
+          end
+        else
+          super(xml, xml_attribute, value)
+        end
+      end
+    end
+  end
+end

data/lib/reactor/cm/xml_attribute.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+module Reactor
+
+  module Cm
+
+    class XmlAttribute
+
+      AVAILABLE_SCOPES = [:get, :set, :create]
+
+      attr_accessor :name
+      attr_accessor :type
+      attr_accessor :scopes
+
+      def initialize(name, type, options)
+        @name = name
+        @type = type.presence || :string
+
+        @scopes =
+        if options[:except].present?
+          AVAILABLE_SCOPES - options[:except]
+        elsif options[:only].present?
+          options[:only]
+        else
+          AVAILABLE_SCOPES
+        end
+      end
+
+      def scope?(name)
+        self.scopes.include?(name)
+      end
+
+    end
+
+  end
+
+end

data/lib/reactor/cm/xml_markup.rb

@@ -0,0 +1,86 @@
+# -*- encoding : utf-8 -*-
+require 'builder'
+
+module Reactor
+  module Cm
+    class XmlMarkup < Builder::XmlMarkup
+
+      def where_key_tag!(base_name, key, value)
+        where_tag!(base_name) do |xml|
+          xml.tag!(key.to_s) do
+            xml.text!(value.to_s)
+          end
+        end
+      end
+
+      def where_tag!(base_name)
+        tag!("#{base_name}-where") do |xml|
+          yield xml
+        end
+      end
+
+      def create_tag!(base_name)
+        tag!("#{base_name}-create") do |xml|
+          yield xml
+        end
+      end
+
+      def delete_tag!(base_name)
+        tag!("#{base_name}-delete")
+      end
+
+      def get_key_tag!(base_name, key)
+        get_tag!(base_name) do |xml|
+          if key.kind_of?(::Array)
+            key.each {|k| xml.tag!(k.to_s) }
+          else
+            xml.tag!(key.to_s) ; end
+        end
+      end
+
+      def get_tag!(base_name)
+        tag!("#{base_name}-get") do |xml|
+          yield xml
+        end
+      end
+
+      def set_key_tag!(base_name, key, value, options = {})
+        set_tag!(base_name) do
+          value_tag!(key, value, options)
+        end
+      end
+
+      def set_tag!(base_name)
+        tag!("#{base_name}-set") do |xml|
+          yield xml
+        end
+      end
+
+      def value_tag!(key, value, options = {})
+        if value.kind_of? ::Array then array_value_tag!(key, value, options)
+        elsif value.kind_of? ::Hash then hash_value_tag!(key, value)
+        else tag!(key.to_s) { text!(value.to_s) }
+        end
+      end
+
+      def array_value_tag!(name, values, options = {})
+        tag!(name.to_s, options) do
+          values.each do |value|
+            tag!('listitem') do
+              text!(value.to_s)
+            end
+          end
+        end
+      end
+
+      def hash_value_tag!(name, hash)
+        hash.each do |value, attr_hash|
+          tag!(name.to_s, attr_hash) do
+            text!(value.to_s)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/reactor/cm/xml_multi_request_error.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+require 'reactor/cm/xml_request_error'
+
+module Reactor
+  module Cm
+    class XmlMultiRequestError < XmlRequestError
+
+    end
+  end
+end