infopark_reactor_migrations 1.5.1

data/lib/reactor/cm/object_base.rb

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

@@ -0,0 +1,100 @@
+require 'reactor/cm/object_base'
+require 'reactor/configuration'
+require 'reactor/cm/language'
+require 'reactor/tools/xml_attributes'
+
+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
+
+        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
+
+        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
+
+      primary_key 'login'
+
+      def initialize(name)
+        @name = name
+      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 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,40 @@
+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,35 @@
+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,85 @@
+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_request.rb

@@ -0,0 +1,82 @@
+require 'net/http'
+require 'reactor/cm/xml_response'
+require 'reactor/cm/xml_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 XmlRequestError, 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,16 @@
+module Reactor
+  module Cm
+    class XmlRequestError < StandardError
+      def initialize(response)
+        @response = response
+        @xml = response.xml
+        super(phrase)
+      end
+
+      def phrase
+        @response.xpath('//phrase').to_s
+      end
+
+    end
+  end
+end

data/lib/reactor/cm/xml_response.rb

@@ -0,0 +1,41 @@
+require 'reactor/tools/response_handler/xml_attribute'
+
+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/configuration.rb

@@ -0,0 +1,7 @@
+module Reactor
+  class Configuration
+    class << self
+      attr_accessor :xml_access
+    end
+  end
+end

data/lib/reactor/migration.rb

@@ -0,0 +1,82 @@
+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'
+
+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,
+    }
+
+    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/migrations/railtie.rb

@@ -0,0 +1,10 @@
+module Reactor
+  module Migrations
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load "tasks/cm_migrate.rake"
+        load "tasks/cm_seeds.rake"
+      end
+    end
+  end
+end

data/lib/reactor/migrations/version.rb

@@ -0,0 +1,5 @@
+module Reactor
+  module Migrations
+    VERSION = "1.5.1"
+  end
+end