ext_ooor 2.3.0.1

data/lib/ooor/rack.rb

@@ -0,0 +1,137 @@
+require 'active_support/concern'
+
+module Ooor
+
+    DEFAULT_OOOR_SESSION_CONFIG_MAPPER = Proc.new do |env|
+      Ooor.logger.debug "\n\nWARNING: using DEFAULT_OOOR_SESSION_CONFIG_MAPPER, you should probably define your own instead!
+      You can define an Ooor::Rack.ooor_session_config_mapper block that will be evaled
+      in the context of the rack middleware call after user is authenticated using Warden.
+      Use it to map a Warden authentication to the OpenERP authentication you want.\n"""
+      {}
+    end
+
+    DEFAULT_OOOR_PUBLIC_SESSION_CONFIG_MAPPER = DEFAULT_OOOR_SESSION_CONFIG_MAPPER
+
+    DEFAULT_OOOR_ENV_DECORATOR = Proc.new do |env|
+    end
+
+    module RackBehaviour
+      extend ActiveSupport::Concern
+      module ClassMethods
+        def ooor_session_config_mapper(&block)
+          @ooor_session_config_mapper = block if block
+          @ooor_session_config_mapper || DEFAULT_OOOR_SESSION_CONFIG_MAPPER
+        end
+
+        def ooor_public_session_config_mapper(&block)
+          @ooor_public_session_config_mapper = block if block
+          @ooor_public_session_config_mapper || DEFAULT_OOOR_PUBLIC_SESSION_CONFIG_MAPPER
+        end
+
+        def decorate_env(&block)
+          @ooor_env_decorator = block if block
+          @ooor_env_decorator || DEFAULT_OOOR_ENV_DECORATOR
+        end
+      end
+
+      def set_ooor!(env)
+        ooor_session = self.get_ooor_session(env)
+        ooor_public_session = self.get_ooor_public_session(env)
+        if defined?(I18n) && I18n.locale
+          lang = Ooor::Locale.to_erp_locale(I18n.locale)
+        elsif http_lang = env["HTTP_ACCEPT_LANGUAGE"]
+          lang = http_lang.split(',')[0].gsub('-', '_')
+        else
+          lang = ooor_session.config['lang'] || 'en_US'
+        end
+        context = {'lang' => lang} #TODO also deal with timezone
+        env['ooor'] = {'context' => context, 'ooor_session'=> ooor_session, 'ooor_public_session' => ooor_public_session}
+        Ooor::Rack.decorate_env.call(env)
+      end
+
+      def get_ooor_public_session(env)
+        config = Ooor.default_config.merge(Ooor::Rack.ooor_public_session_config_mapper.call(env))
+        Ooor.session_handler.retrieve_session(config, :noweb)
+      end
+
+      def get_ooor_session(env)
+        ruby_session_id = ::Rack::Request.new(env).session.id
+        session = Ooor.session_handler.sessions[ruby_session_id]
+        unless session # session could have been used by an other worker, try getting it
+          config = Ooor.default_config.merge(Ooor::Rack.ooor_session_config_mapper.call(env))
+          if config[:session_sharing] # same session_id as Odoo mode
+            cookies_hash = env['rack.request.cookie_hash'] || ::Rack::Request.new(env).cookies
+            spec = cookies_hash['session_id']
+          else
+            spec = ruby_session_id
+          end
+          web_session = Ooor.session_handler.get_web_session(spec) if spec # created by some other worker?
+          web_session ||= {session_id: cookies_hash['session_id']} if config[:session_sharing]
+          session = Ooor.session_handler.retrieve_session(config, spec, web_session)
+          session.config[:params] = {email: env['warden'].try(:user).try(:email)}
+        end
+        session
+      end
+
+      def set_ooor_session!(env, status, headers, body)
+        case headers["Set-Cookie"]
+        when nil, ''
+          headers["Set-Cookie"] = ""
+        when Array
+          headers["Set-Cookie"] = headers["Set-Cookie"].join("\n")
+        end
+
+        ooor_session = env['ooor']['ooor_session']
+        if ooor_session.config[:session_sharing]
+          share_openerp_session!(headers, ooor_session)
+        end
+        response = ::Rack::Response.new body, status, headers
+        response.finish
+      end
+
+      def share_openerp_session!(headers, ooor_session)
+        if ooor_session.config[:username] == 'admin'
+          if ooor_session.config[:force_session_sharing]
+            Ooor.logger.debug "Warning! force_session_sharing mode with admin user, this may be a serious security breach! Are you really in development mode?"
+          else
+            raise "Sharing OpenERP session for admin user is suicidal (use force_session_sharing in dev mode and be paranoiac about it)"
+          end
+        end
+        cookie = ooor_session.web_session[:cookie]
+        headers["Set-Cookie"] = [headers["Set-Cookie"], cookie].join("\n")
+
+        if ooor_session.web_session[:sid] #v7
+          session_id = ooor_session.web_session[:session_id]
+          headers["Set-Cookie"] = [headers["Set-Cookie"],
+            "instance0|session_id=%22#{session_id}%22; Path=/",
+            "last_used_database=#{ooor_session.config[:database]}; Path=/",
+            "session_id=#{session_id}; Path=/",
+          ].join("\n")
+        end
+      end
+
+    end
+
+    class Rack
+      include RackBehaviour
+
+      attr_accessor :app, :env
+
+      def initialize(app=nil)
+        @app=app
+      end
+
+      def call(env)
+        threadsafed = dup
+        threadsafed.env = env
+        threadsafed._call
+      end
+
+      def _call
+        set_ooor!(env)
+        status, headers, body = @app.call(env)
+        set_ooor_session!(env, status, headers, body)
+      end
+    end
+
+end

data/lib/ooor/railtie.rb

@@ -0,0 +1,27 @@
+require "rails/railtie"
+require "ooor/rack"
+require "yaml"
+
+module Ooor
+  class Railtie < Rails::Railtie
+    initializer "ooor.middleware" do |app|
+      Ooor.logger = Rails.logger unless $0 != 'irb'
+      Ooor.cache_store = Rails.cache
+      Ooor.new("#{Rails.root}/config/ooor.yml")
+      Ooor.logger.level = Ooor.default_config[:log_level] if Ooor.default_config[:log_level]
+
+      unless Ooor.default_config[:disable_locale_switcher]
+        if defined?(Rack::I18nLocaleSwitcher)
+          app.middleware.use '::Rack::I18nLocaleSwitcher'
+        else
+          puts "Could not load Rack::I18nLocaleSwitcher, if your application is internationalized, make sure to include rack-i18n_locale_switcher in your Gemfile"
+        end
+      end
+      if defined?(::Warden::Manager)
+        app.middleware.insert_after ::Warden::Manager, ::Ooor::Rack
+      else
+        app.middleware.insert_after ::Rack::Head, ::Ooor::Rack
+      end
+    end
+  end
+end

data/lib/ooor/reflection.rb

@@ -0,0 +1,151 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/inclusion'
+
+module Ooor
+  # = Active Record Reflection
+  # NOTE this is a shrinked copy of ActiveRecord reflection.rb
+  # the few necessary hacks are explicited with a FIXME or a NOTE
+  # an addition Ooor specific reflection module completes this one explicitely
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+# NOTE we do the following differently in Ooor because we really don't want to share
+# reflactions between the various sessions!!     
+#    included do
+#      class_attribute :reflections
+#      self.reflections = {}
+#    end
+
+    # Reflection enables to interrogate Active Record classes and objects
+    # about their associations and aggregations. This information can,
+    # for example, be used in a form builder that takes an Active Record object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
+    #
+    # MacroReflection class has info for AggregateReflection and AssociationReflection
+    # classes.
+    module ClassMethods
+      #def create_reflection(macro, name, options, active_record) #NOTE overriden in Ooor
+
+      # Returns an array of AggregateReflection objects for all the aggregations in the class.
+      def reflect_on_all_aggregations
+        reflections.values.grep(AggregateReflection)
+      end
+
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
+      #
+      #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
+      #
+      def reflect_on_aggregation(aggregation)
+        reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
+      end
+
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values.grep(AssociationReflection)
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+
+      # def reflect_on_association(association) # NOTE overriden in Ooor
+
+      # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
+      end
+    end
+
+
+    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    class MacroReflection
+      # Returns the name of the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      # Returns the macro type.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
+
+      attr_reader :active_record
+
+      attr_reader :plural_name # :nodoc:
+
+      def initialize(macro, name, options, active_record)
+        @macro         = macro
+        @name          = name
+        @options       = options
+        @active_record = active_record
+#        @plural_name   = active_record.pluralize_table_names ? #FIXME hacked for OOOR
+#                            name.to_s.pluralize : name.to_s
+      end
+
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
+#      def klass #NOTE overriden in Ooor
+#        @klass ||= class_name.constantize
+#      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
+      # and +other_aggregation+ has an options hash assigned to it.
+      def ==(other_aggregation)
+        super ||
+          other_aggregation.kind_of?(self.class) &&
+          name == other_aggregation.name &&
+          other_aggregation.options &&
+          active_record == other_aggregation.active_record
+      end
+
+#      def sanitized_conditions #:nodoc: #NOTE not applicable in Ooor
+#        @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
+#      end
+
+      private
+        def derive_class_name
+          name.to_s.camelize
+        end
+    end
+
+
+    # Holds all the meta-data about an aggregation as it was specified in the
+    # Active Record class.
+    class AggregateReflection < MacroReflection #:nodoc:
+    end
+
+    # Holds all the meta-data about an association as it was specified in the
+    # Active Record class.
+    #class AssociationReflection < MacroReflection #:nodoc: #NOTE totally overriden in Ooor
+
+    # Holds all the meta-data about a :through association as it was specified
+    # in the Active Record class.
+    #class ThroughReflection < AssociationReflection #:nodoc: #NOTE commented out because not used in Ooor
+  end
+end

data/lib/ooor/reflection_ooor.rb

@@ -0,0 +1,121 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/inclusion'
+
+module Ooor
+  # = Ooor Reflection
+  module ReflectionOoor # :nodoc:
+    extend ActiveSupport::Concern
+
+    def column_for_attribute(name)
+      self.class.columns_hash[name.to_s]
+    end
+
+    def has_attribute?(attr_name)
+      self.class.columns_hash.key?(attr_name.to_s)
+    end
+
+    module ClassMethods
+      def reflections
+        @reflections ||= {}
+      end
+
+      def reflections=(reflections)
+        @reflections = reflections
+      end
+
+      def columns_hash(view_fields=nil)
+        if view_fields || !@t.columns_hash
+          view_fields ||= {}
+          reload_fields_definition()
+          @t.columns_hash ||= {}
+          @t.fields.each do |k, field|
+            unless @t.associations_keys.index(k)
+              @t.columns_hash[k] = field.merge({type: to_rails_type(view_fields[k] && view_fields[k]['type'] || field['type'])})
+            end
+          end
+          @t.columns_hash
+        else
+          @t.columns_hash
+        end
+      end
+
+      def create_reflection(name)
+        reload_fields_definition()
+        options = {}
+        relation = all_fields[name]['relation']
+        options[:class_name] = relation
+        if many2one_associations.keys.include?(name)
+          macro = :belongs_to
+        elsif many2many_associations.keys.include?(name)
+          macro = :has_and_belongs_to_many
+        elsif one2many_associations.keys.include?(name)
+          macro = :has_many
+        end
+        reflection = Reflection::AssociationReflection.new(macro, name, options, nil)#active_record) #TODO active_record?
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+
+      def reflect_on_association(association)
+        reflections[association] ||= create_reflection(association.to_s).tap do |reflection|
+          reflection.session = session
+        end
+      end
+    end
+
+  end
+end
+
+
+module Ooor
+  # = Active Record Reflection
+  module Reflection # :nodoc:
+
+    class MacroReflection
+      attr_accessor :session
+    end
+
+    # Holds all the meta-data about an association as it was specified in the
+    # Active Record class.
+    class AssociationReflection < MacroReflection #:nodoc:
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      def klass
+#        @klass ||= active_record.send(:compute_type, class_name)
+#        @klass ||= session.class_name_from_model_key(class_name).constantize
+        @klass = session.const_get(class_name)
+      end
+
+      def initialize(macro, name, options, active_record)
+        super
+        @collection = macro.in?([:has_many, :has_and_belongs_to_many])
+      end
+
+      # Returns a new, unsaved instance of the associated class. +options+ will
+      # be passed to the class's constructor.
+      def build_association(*options, &block)
+        klass.new(*options, &block)
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        @collection
+      end
+
+
+    end
+
+  end
+end

data/lib/ooor/relation.rb

@@ -0,0 +1,204 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2009-TODAY Akretion LTDA (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+#TODO chainability of where via scopes
+
+module Ooor
+  # = Similar to Active Record Relation
+  # subset of https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/query_methods.rb
+  class Relation
+    attr_reader :klass, :loaded
+    attr_accessor :options, :count_field, :includes_values, :eager_load_values, :preload_values,
+                  :select_values, :group_values, :order_values, :reorder_flag, :joins_values, :where_values, :having_values,
+                  :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value, :page_value, :per_value
+    alias :loaded? :loaded
+    alias :model :klass
+
+    def build_where(opts, other = [])#TODO OpenERP domain is more than just the intersection of restrictions
+      case opts
+      when Array || '|' || '&'
+        [opts]
+      when Hash
+        opts.keys.map {|key|["#{key}", "=", opts[key]]}
+      end
+    end
+
+    def where(opts, *rest)
+      relation = clone
+      if opts.is_a?(Array) && opts.any? {|e| e.is_a? Array}
+        relation.where_values = opts
+      else
+        relation.where_values += build_where(opts, rest) unless opts.blank?
+      end
+      relation
+    end
+
+#    def having(*args)
+#      relation = clone
+#      relation.having_values += build_where(*args) unless args.blank?
+#      relation
+#    end
+
+    def limit(value)
+      relation = clone
+      relation.limit_value = value
+      relation
+    end
+
+    def offset(value)
+      relation = clone
+      relation.offset_value = value
+      relation
+    end
+
+    def order(*args)
+      relation = clone
+      relation.order_values += args.flatten unless args.blank? || args[0] == false
+      relation
+    end
+
+    def includes(*values)
+      relation = clone
+      relation.includes_values = values
+      relation
+    end
+
+#    def count(column_name = nil, options = {}) #TODO possible to implement?
+#      column_name, options = nil, column_name if column_name.is_a?(Hash)
+#      calculate(:count, column_name, options)
+#    end
+
+    def initialize(klass, options={})
+      @klass = klass
+      @where_values = []
+      @loaded = false
+      @options = options
+      @count_field = false
+      @offset_value = 0
+      @order_values = []
+    end
+
+    def new(*args, &block)
+      #TODO inject current domain in *args
+      @klass.new(*args, &block)
+    end
+
+    alias build new
+
+    def reload
+      reset
+      to_a # force reload
+      self
+    end
+
+    def initialize_copy(other)
+      reset
+    end
+
+    def reset
+      @first = @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil
+      @should_eager_load = @join_dependency = nil
+      @records = []
+      self
+    end
+
+    def apply_finder_options(options)
+      relation = clone
+      relation.options = options #TODO this may be too simplified for chainability, merge smartly instead?
+      relation
+    end
+
+    def where_values
+      if @options && @options[:domain]
+        @options[:domain]
+      else
+        @where_values
+      end
+    end
+
+    # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:all)</tt>.
+    def all(*args)
+      args.any? ? apply_finder_options(args.first).to_a : to_a
+    end
+
+    def first(*args)
+      limit(1).order('id').all(*args).first
+    end
+
+    def last(*args)
+      limit(1).order('id DESC').all(*args).first
+    end
+
+    def to_a
+      if loaded?
+        @records
+      else
+        if @order_values.empty?
+          search_order = false
+        else
+          search_order = @order_values.join(", ")
+        end
+
+        if @options && @options[:name_search]
+          name_search = @klass.name_search(@options[:name_search], where_values, 'ilike', @options[:context], @limit_value)
+          @records = name_search.map do |tuple|
+            @klass.new({name: tuple[1]}, []).tap { |r| r.id = tuple[0] } #TODO load the fields optionally
+          end
+        else
+          load_records_page(search_order)
+        end
+      end
+    end
+
+    def eager_loading?
+      false
+    end
+
+    def inspect
+      entries = to_a.take([limit_value, 11].compact.min).map!(&:inspect)
+      entries[10] = '...' if entries.size == 11
+
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
+    end
+
+    protected
+
+    def load_records_page(search_order)
+      if @per_value && @page_value
+        offset = @per_value * @page_value
+        limit = @per_value
+      else
+        offset = @offset_value
+        limit = @limit_value || false
+      end
+      @loaded = true
+      opts = @options.merge({
+          domain: where_values,
+          offset: offset,
+          limit: limit,
+          order: search_order,
+          includes: includes_values,
+      })
+      scope = @options.delete(:ids) || :all
+      if scope == []
+        @records = []
+      else
+        @records = @klass.find(scope, opts)
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if Array.method_defined?(method)
+        to_a.send(method, *args, &block)
+      elsif @klass.respond_to?(method)
+        @klass.send(method, *args, &block)
+      else
+        @klass.rpc_execute(method.to_s, to_a.map {|record| record.id}, *args)
+      end
+    end
+
+  end
+end