infopark_reactor_migrations 1.5.1

data/lib/reactor/cm/obj.rb

@@ -0,0 +1,402 @@
+module Reactor
+  module Cm
+    class Obj
+      attr_reader :obj_id
+      OBJ_ATTRS = [:permalink, :objClass, :workflowName, :name, :suppressExport, :parent]
+      ATTR_LENGTH_CONSTRAINT = {:name => 250, :title => 250}
+
+      def self.create(name, parent, objClass)
+        obj = Obj.new(name)
+        obj.send(:create, parent, objClass)
+        obj
+      end
+
+      def self.exists?(path_or_id)
+        obj = Obj.new
+        begin
+          obj.send(:load, path_or_id).ok?
+        rescue
+          return false
+        end
+      end
+
+      def self.get(path_or_id)
+        obj = Obj.new
+        obj.send(:load, path_or_id)
+        obj
+      end
+
+      def self.delete_where(conditions)
+        request = XmlRequest.prepare do |xml|
+
+          xml.tag!('obj-where') do
+            conditions.each do |key, value|
+              xml.tag!(key, value)
+            end
+          end
+          xml.tag!("obj-delete")
+        end
+        request.execute!
+      end
+
+      def upload(data_or_io, extension)
+        data = (data_or_io.kind_of?IO) ? data_or_io.read : data_or_io
+        base64_data = Base64.encode64(data)
+
+        set(:contentType, extension)
+        set(:blob, {base64_data=>{:encoding=>'base64'}})
+      end
+
+      def get(key)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @obj_id)
+          xml.get_key_tag!(base_name, key)
+        end
+        response = request.execute!
+        result = response.xpath("//#{key}")
+        if result.children.map {|i| i.respond_to?(:name) && (i.name == "listitem") }.reduce(:&)
+          result.children.map {|i| i.text.to_s }
+        else
+          result = result.text unless result.is_a? Array
+          result
+        end
+      end
+
+      def set(key, value, options={})
+        key = key.to_sym
+        value = value[0, ATTR_LENGTH_CONSTRAINT[key]] if ATTR_LENGTH_CONSTRAINT[key]
+        if OBJ_ATTRS.include?(key) then @obj_attrs[key] = value
+        else
+          @attrs[key] = value
+        end
+        @attr_options[key] = options
+      end
+
+      def permission_granted_to(user, permission)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @obj_id)
+          xml.get_tag!(base_name) do
+            xml.tag!('permissionGrantedTo', :permission => permission, :user => user)
+          end
+        end
+        response = request.execute!
+        response.xpath("//permissionGrantedTo/text()") == "1"
+      end
+
+      def permission_set(permission, groups)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, :id, @obj_id)
+
+          options = {
+            :permission => permission,
+            :type => :list,
+          }
+
+          xml.set_key_tag!(base_name, :permission, groups, options)
+        end
+
+        request.execute!
+      end
+
+      def permission_grant(permission, groups)
+        self.permission_command('GrantTo', permission, groups)
+      end
+
+      def permission_revoke(permission, groups)
+        self.permission_command('RevokeFrom', permission, groups)
+      end
+
+      def permission_clear(permission)
+        self.permission_set(permission, [])
+      end
+
+      def get_links(attr)
+        get_link_ids(attr).map {|id| Link.get(id)}
+      end
+
+      def set_links(attr, new_links_as_hashes)
+        get_links(attr).map(&:delete!)
+        new_links_as_hashes.each do |link_hash|
+          Link.create_inside(self, attr, link_hash[:destination_url], link_hash[:title])
+        end
+      end
+
+      def set_link(attr, path)
+        old_links = get_links(attr)
+        if old_links.length == 1
+          old_link = old_links.first
+          old_link.dest_url = path
+          @links[attr] = [old_link]
+        else
+          @removed_links = old_links
+          @links[attr] = [Link.create_inside(self, attr, path)]
+        end
+      end
+
+      def save!
+        edit! if not edited?
+        content = edited_content
+        @request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!('content', 'id', content)
+          xml.tag!("content-set") do
+            @attrs.each do |key, value|
+              if (@attr_options[key] || {})[:cdata]
+                xml.tag!(key.to_s) do
+                  xml.cdata!(value)
+                end
+              else
+                xml.value_tag!(key.to_s, value)
+              end
+            end
+          end
+        end
+        response = @request.execute!
+        return response if !response.ok?
+
+        unless @obj_attrs.empty?
+          request = XmlRequest.prepare do |xml|
+            xml.where_key_tag!(base_name, 'id', @obj_id)
+            xml.set_tag!(base_name) do
+              @obj_attrs.each do |key, value|
+                xml.value_tag!(key, value)
+              end
+            end
+          end
+          response = request.execute!
+        end
+
+        return response if !response.ok?
+
+        @removed_links.each do |link|
+          link.delete!
+        end
+
+        @links.each do |attr, links|
+          links.each do |link|
+            link.save!
+          end
+        end
+      end
+
+
+      def release!
+        simple_command("release")
+      end
+
+      def edit!
+        simple_command("edit")
+      end
+
+      def take!
+        simple_command("take")
+      end
+
+      def forward!
+        simple_command("forward")
+      end
+
+      def commit!
+        simple_command("commit")
+      end
+
+      def reject!
+        simple_command("reject")
+      end
+
+      def sign!
+        simple_command("sign")
+      end
+
+      def valid_actions
+        vcak = get('validControlActionKeys')
+        (vcak || []).map(&:to_s)
+      end
+
+      def copy(new_parent, recursive = false, new_name = nil)
+        request = XmlRequest.prepare do |xml|
+          xml.tag!('obj-where') do
+            xml.tag!("id", @obj_id)
+          end
+          xml.tag!("obj-copy") do
+            xml.tag!("parent", new_parent)
+            xml.tag!("name", new_name) if new_name
+            xml.tag!("recursive", "1") if recursive
+          end
+        end
+        response = request.execute!
+        response.xpath("//obj/id").text
+      end
+
+      def delete!
+        simple_command("delete")
+      end
+
+      def remove_active_contents!
+        simple_command("removeActiveContents")
+      end
+
+      def remove_archived_contents!
+        simple_command("removeArchivedContents")
+      end
+
+      def resolve_refs!
+        request = XmlRequest.prepare do |xml|
+          xml.tag!('content-where') do
+            xml.tag!('objectId', @obj_id)
+            xml.tag!('state', 'edited')
+          end
+          xml.tag!('content-resolveRefs')
+        end
+        response = request.execute!
+      end
+
+      def path
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @obj_id)
+          xml.get_key_tag!(base_name, 'path')
+        end
+        response = request.execute!
+        response.xpath("//obj/path").text
+      end
+
+      def edited?
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @obj_id)
+          xml.get_key_tag!(base_name, 'isEdited')
+        end
+        response = request.execute!
+        response.xpath("//isEdited").text == "1"
+      end
+
+      def reasons_for_incomplete_state
+        request = XmlRequest.prepare do |xml|
+          xml.tag!('content-where') do
+            xml.tag!('objectId', @obj_id)
+            xml.tag!('state', 'edited')
+          end
+          xml.get_key_tag!('content', 'reasonsForIncompleteState')
+        end
+        response = request.execute!
+        result = response.xpath('//reasonsForIncompleteState/*')
+        result.kind_of?(Array) ? result.map(&:text).map(&:to_s) : [result.to_s]
+      end
+
+      def editor
+        request = XmlRequest.prepare do |xml|
+          xml.tag!('content-where') do
+            xml.tag!('objectId', @obj_id)
+            xml.tag!('state', 'edited')
+          end
+          xml.get_key_tag!('content', 'editor')
+        end
+        response = request.execute!
+        response.xpath('//editor').text
+      end
+
+      def edited_content
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @obj_id)
+          xml.get_key_tag!(base_name, 'editedContent')
+        end
+        response = request.execute!
+        response.xpath("//editedContent").text
+      end
+
+      protected
+      def simple_command(cmd_name)
+        @request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @obj_id)
+          xml.tag!("#{base_name}-#{cmd_name}")
+        end
+        response = @request.execute!
+      end
+
+      def base_name
+        'obj'
+      end
+
+      def get_content_attr_text(attr)
+        content = edited_content
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!('content', 'id', content)
+          xml.get_tag!('content') do
+            xml.tag!(attr.to_s)
+          end
+        end
+        response = request.execute!
+        txt = response.xpath("//#{attr}/text()")
+        txt.class.unnormalize(txt.to_s)
+      end
+
+      def get_link_ids(attr)
+        content = edited_content
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!('content', 'id', content)
+          xml.get_key_tag!('content', attr.to_s)
+        end
+        response = request.execute!
+        result = response.xpath("//listitem/text()")
+        result.kind_of?(Array) ? result : [result]
+      rescue XmlRequestError
+        []
+      end
+
+      def self.extract_id(response)
+        response.xpath("//obj/id").text
+      end
+
+      def initialize(name=nil)
+        @name = name
+        @attrs = {}
+        @obj_attrs = {}
+        @links = {}
+        @removed_links = []
+        @attr_options = {}
+      end
+
+      def create(parent, objClass)
+        @request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'path', parent)
+          xml.create_tag!(base_name) do
+            xml.tag!('objClass') do
+              xml.text!(objClass)
+            end
+            xml.tag!('name') do
+              xml.text!(@name)
+            end
+          end
+        end
+        response = @request.execute!
+        @obj_id = self.class.extract_id(response)
+        response
+      end
+
+      def load(path_or_id)
+        key = (/^\// =~ path_or_id.to_s) ? 'path' : 'id'
+        value = path_or_id
+
+        @request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, key.to_s, value.to_s)
+          xml.get_key_tag!(base_name, 'id')
+        end
+        response = @request.execute!
+        @obj_id = self.class.extract_id(response)
+        response
+      end
+
+      def permission_command(type, permission, groups)
+        request = XmlRequest.prepare do |xml|
+          xml.where_key_tag!(base_name, 'id', @obj_id)
+
+          xml.tag!("#{base_name}-permission#{type}", :permission => permission) do
+            groups.each do |name|
+              xml.tag!(:group, name)
+            end
+          end
+        end
+
+        request.execute!
+      end
+    end
+  end
+end

data/lib/reactor/cm/obj_class.rb

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