infopark_reactor 1.5.1

data/lib/reactor/rc_independent.rb

@@ -0,0 +1,13 @@
+module Reactor
+  module RcIndependent
+    module Base
+      def really_edited?
+        crul_obj.edited?
+      end
+
+      def really_released?
+        crul_obj.released?
+      end
+    end
+  end
+end

data/lib/reactor/session.rb

@@ -0,0 +1,48 @@
+require 'singleton'
+require 'observer'
+
+require 'reactor/cm/bridge'
+require 'reactor/cache/user'
+
+class Reactor::Session
+  attr_reader :user_name, :session_id
+  include Singleton
+  include Observable
+
+  def login(session_id)
+    if !logged_in?(session_id)
+      self.user_name = authenticate(session_id)
+    end
+  end
+
+  def destroy
+    self.session_id = self.user_name = nil
+  end
+
+  def logged_in?(session_id)
+    self.session_id.present? && self.user? && self.session_id == session_id
+  end
+
+  def user?
+    self.user_name.present?
+  end
+
+  def user
+    Reactor::Cache::User.instance.get(self.user_name)
+  end
+
+  def user_name=(new_user_name)
+    @user_name = new_user_name
+    changed(true) # I will find and burn your house to the ground if you remove this line
+    notify_observers(@user_name)
+  end
+
+  protected
+  attr_writer :session_id
+
+  def authenticate(session_id)
+    self.session_id = session_id
+    Reactor::Cm::Bridge.login_for(session_id)
+  end
+
+end

data/lib/reactor/session/observers.rb

@@ -0,0 +1,32 @@
+require 'reactor/session'
+
+module Reactor::Session::Observers
+  class PermissionCacheInvalidator
+    def update(user_name)
+      #puts '%%% invalidating permission cache'
+      Reactor::Cache::Permission.instance.invalidate(user_name)
+    end
+  end
+
+  class UserCacheInvalidator
+    def update(user_name)
+      #puts '%%% invalidating user cache'
+      Reactor::Cache::User.instance.invalidate(user_name)
+    end
+  end
+
+  class CmsAccessDataPropagator
+    def update(user_name)
+      #puts '%%% propagating user'
+      Reactor::Configuration.xml_access[:username] = user_name
+    end
+  end
+
+  self.constants.each do |possible_observer_name|
+    possible_observer = self.const_get(possible_observer_name)
+    if possible_observer.method_defined?(:update)
+      Reactor::Session.instance.add_observer(possible_observer.new)
+    end
+  end
+end
+  

data/lib/reactor/session/user.rb

@@ -0,0 +1,22 @@
+require 'reactor/cm/user'
+
+module Reactor
+  class Session
+    class User
+      def initialize(user_name)
+        # Rails.logger.debug "Reading user #{user_name} from CM"
+        user      = Reactor::Cm::User.new(user_name)
+        @user_name= user_name
+        @groups   = user.groups
+        @language = user.language
+        @superuser= user.is_root?
+      end
+
+      attr_reader :user_name, :groups, :language
+
+      def superuser?
+        @superuser == true
+      end
+    end
+  end
+end

data/lib/reactor/streaming_upload.rb

@@ -0,0 +1,22 @@
+module Reactor
+  module StreamingUpload
+    module Base
+      # Uploads a file/string into a CM. Requires call to save afterwards(!)
+      # @param [String, IO] data_or_io
+      # @param [String] extension file extension
+      # @raise [Reactor::UploadError] raised when CM does not respond with
+      #  streaming ticket (i.e. has not accepted the file)
+      # @raise [Timeout::Error] if upload to CM takes more than:
+      #  60 seconds for IO streaming IO or 30 seconds for memory
+      #
+      # NOTE: behavior of this method is slightly different, than the
+      # traditional method: this method opens a TCP connection to the CM,
+      # transfers the data and stores the reference (so called streaming
+      # ticket). You still need to call save! afterwards.
+      def upload(data_or_io, extension)
+        self.uploaded = true
+        Reactor::Tools::Uploader.new(crul_obj).upload(data_or_io, extension)
+      end
+    end
+  end
+end

data/lib/reactor/sudo.rb

@@ -0,0 +1,11 @@
+module Reactor
+  module Sudo
+    def self.su(other_user_name, &block)
+      current_user_name = Reactor::Session.instance.user_name
+      Reactor::Session.instance.user_name = other_user_name
+      yield
+    ensure
+      Reactor::Session.instance.user_name = current_user_name || 'root'
+    end
+  end
+end

data/lib/reactor/support/link_matcher.rb

@@ -0,0 +1,44 @@
+module Reactor
+  module Support
+    class LinkMatcher
+      def initialize(url)
+        @url = url
+      end
+
+      def recognized?
+        match = match_url
+        (match[:action] == "index") &&
+          (match[:controller] == "rails_connector/cms_dispatch") &&
+          ((match[:id].present? && Obj.exists?(match[:id].to_i)) ||
+          (match[:permalink].present? && Obj.exists?(:permalink => match[:permalink])))
+      rescue ActionController::RoutingError
+        return false
+      end
+
+      def rewrite_url
+        match = match_url
+
+        if match[:permalink].present?
+          append_fragment_and_query Obj.find_by_permalink(match[:permalink]).path 
+        elsif match[:id].present?
+          append_fragment_and_query Obj.find(match[:id].to_i).path
+        end
+      end
+
+      private
+      def match_url
+        relative_url_root = ENV['RAILS_RELATIVE_URL_ROOT']
+        url = @url.clone
+        url.gsub!(/^#{Regexp.escape(relative_url_root)}/, '') if relative_url_root.present?
+        Rails.application.routes.recognize_path(url)
+      end
+
+      def append_fragment_and_query(obj_path)
+        uri = URI.parse(@url)
+        obj_path += "?#{uri.query}" if uri.query
+        obj_path += "##{uri.fragment}" if uri.fragment
+        obj_path
+      end
+    end
+  end
+end

data/lib/reactor/tools/workflow_generator.rb

@@ -0,0 +1,195 @@
+module Reactor
+  module Tools
+    class WorkflowGenerator
+      attr_reader :obj, :users, :editors, :correctors, :groups, :workflow_name
+
+      def initialize(options)
+        @editors    = options[:editors]
+        @correctors = options[:correctors]
+        @users      = @editors + @correctors
+        @groups     = personal_groups(@users)
+        @class_name = options[:obj_class] || generate_obj_class_name
+        @workflow_name  = options[:workflow_name] || generate_workflow_name
+        @obj_name   = options[:obj_name] || generate_obj_name
+      end
+
+      def generate!
+        create_groups
+        create_users
+        create_signatures
+        create_workflow
+        create_obj_class
+        create_obj
+        set_permissions
+        start_workflow
+      end
+
+      def destroy!
+        destroy_objs
+        destroy_obj_class
+        destroy_workflow
+        destroy_users
+        destroy_groups
+        destroy_signatures
+      end
+
+      def personal_group(user)
+        "#{user}_group"
+      end
+
+      protected
+
+      def personal_signature(user)
+        "#{user}_signature"
+      end
+
+      def personal_groups(users)
+        users.map {|user| personal_group(user) }
+      end
+
+      def create_groups
+        @groups.each do |group|
+          if Reactor::Cm::Group.exists?(group)
+            Reactor::Cm::Group.get(group)
+          else
+            Reactor::Cm::Group.create(:name => group)
+          end
+        end
+      end
+
+      def create_users
+        @users.each do |user|
+          if Reactor::Cm::User::Internal.exists?(user)
+            internal_user = Reactor::Cm::User::Internal.get(user)
+          else
+            internal_user = Reactor::Cm::User::Internal.create(user, personal_group(user))
+          end
+
+          internal_user.change_password('thepasswordispassword')
+        end
+      end
+
+      def create_signatures
+        # hash storing users as keys and attribute names as values
+        @signatures = {}
+        @users.each do |user|
+          signature = personal_signature(user)
+          if Reactor::Cm::Attribute.exists?(signature)
+            #Reactor::Cm::Attribute.get(signature)
+            @signatures[user] = signature
+          else
+            Reactor::Cm::Attribute.create(signature, 'signature')
+            @signatures[user] = signature
+          end
+        end
+      end
+
+      def create_workflow
+        if Reactor::Cm::Workflow.exists?(@workflow_name)
+          @workflow = Reactor::Cm::Workflow.get(@workflow_name)
+        else
+          @workflow = Reactor::Cm::Workflow.create(@workflow_name)
+        end
+
+        # set up workflow steps
+        @workflow.edit_groups = personal_groups(@editors)
+
+        serialized_signatures = []
+        @correctors.each do |corrector|
+          signature = {
+            :group => personal_group(corrector),
+            :attribute => @signatures[corrector]
+          }
+          serialized_signatures << signature
+        end
+        @workflow.signatures = serialized_signatures
+
+        @workflow.save!
+        @workflow.reload
+      end
+
+      def create_obj_class
+        @obj_class  = if Reactor::Cm::ObjClass.exists?(@class_name)
+          Reactor::Cm::ObjClass.get(@class_name)
+        else
+          Reactor::Cm::ObjClass.create(@class_name, 'publication')
+        end
+      end
+
+      def create_obj
+        @obj = Reactor::Cm::Obj.create(@obj_name, '/', @class_name)
+        @obj.set(:workflowName, @workflow_name)
+        @obj.save!
+      end
+
+      def set_permissions
+        # get RC object
+        @rc_obj = RailsConnector::Obj.find(@obj.obj_id)
+
+        # use nice API to set permissions
+        @groups.each do |group|
+          @rc_obj.permission.grant(:read, group)
+          @rc_obj.permission.grant(:write, group)
+        end
+
+        # Allow Dirk to release the object
+        @rc_obj.permission.grant(:root, personal_group(@correctors.last))
+      end
+
+      def start_workflow
+        @obj.release!
+        Reactor::Sudo.su(@editors.first) do
+          @obj.edit!
+        end
+      end
+
+      def destroy_objs
+        RailsConnector::Obj.find_all_by_obj_class(@class_name).each(&:destroy)
+      end
+
+      def destroy_obj_class
+        @obj_class.delete!
+      end
+
+      def destroy_workflow
+        @workflow.delete!
+      end
+
+      def destroy_users
+        @users.each do |user|
+          Reactor::Cm::User::Internal.get(user).delete!
+        end
+      end
+
+      def destroy_groups
+        @groups.each do |group|
+          Reactor::Cm::Group.get(group).delete!
+        end
+      end
+
+      def destroy_signatures
+        @signatures.values.each do |attribute|
+          Reactor::Cm::Attribute.get(attribute).delete!
+        end
+      end
+
+      def generate_workflow_name
+        "GeneratedWorkflow#{generate_token}"
+      end
+
+      def generate_obj_name
+        "generated_obj#{generate_token}"
+      end
+
+      def generate_obj_class_name
+        "GeneratedObjClass#{generate_token}"
+      end
+
+      def generate_token
+        characters = ('0'..'9').to_a + ('A'..'Z').to_a + ('a'..'z').to_a
+        token = 8.times.map { characters[rand(characters.length)] }.join
+      end
+
+    end
+  end
+end

data/lib/reactor/validations.rb

@@ -0,0 +1,55 @@
+module Reactor
+  # This module provides standard validations for Objs (:permalink, :parent_obj_id, :name, :obj_class),
+  # and presence validations for all mandatory fields.
+  # It also creates new validation context :release
+  #
+  # @todo :in validations for (multi)enums
+  # @todo link validations?
+  module Validations
+    module Base
+     def self.included(base)
+        base.extend(ClassMethods)
+        # Common validations for all Objs
+        base.class_eval do
+          validates :permalink,     :format => { :with => /^[-_$.\/a-zA-Z0-9]*$/ }
+          validates :parent_obj_id, :numericality => { :only_integer => true }, :on => :create
+          validates :name,          :presence => true, :on => :create
+          validates :obj_class,     :presence => true, :on => :create
+        end
+      end
+
+      # Wraps around Reactor::Persistence::Base#release! and validates object
+      # in :release context before release. Raises exception when invalid.
+      # @raise [ActiveRecord::RecordInvalid] validations registered for :release failed
+      def release!
+        raise(ActiveRecord::RecordInvalid.new(self)) unless valid?(:release)
+        return super
+      end
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        super(subclass) # if you remove this line, y'll get TypeError: can't dup NilClass at some point
+
+        # Add validation for each mandatory attribute
+        mandatory_attrs = __mandatory_cms_attributes(subclass.name)
+        mandatory_attrs.each  do |attr|
+          subclass.send(:validates_presence_of, attr.to_sym, :on => :release)
+        end if mandatory_attrs
+
+        cms_attributes  = __cms_attributes(subclass).values
+        # Add validation for linklist & multienum [minSize/maxSize]
+        array_attributes= cms_attributes.select {|attr| ["linklist", "multienum"].include?(attr.attribute_type) }
+        array_attributes.each do |attr|
+          length_hash = {}
+          length_hash[:minimum] = attr.min_size if attr.min_size && "linklist" != attr.attribute_type # CMS ignores minimum for linklists.
+          length_hash[:maximum] = attr.max_size if attr.max_size
+        
+          subclass.send(:validates, attr.attribute_name.to_sym, :length => length_hash, :on => :release) unless length_hash.empty?
+        end
+
+        subclass
+      end
+    end
+  end
+end