ooor 1.9.2 → 2.0.0

data/lib/ooor/reflection_ooor.rb

@@ -0,0 +1,92 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/inclusion'
+
+module Ooor
+  # = Ooor Reflection
+  module ReflectionOoor # :nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def set_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
+      end
+
+      def column_for_attribute(name)
+        columns_hash[name.to_s]
+      end
+
+      def create_reflection(name)
+        options = {}
+        if many2one_associations.keys.include?(name)
+          macro = :belongs_to
+          relation = many2one_associations[name]['relation'] #TODO prefix?
+          const_get(relation)
+          options[:class_name] = relation #TODO or pass it camelized already?
+        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?
+#        case macro
+#          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+#            klass = options[:through] ? ThroughReflection : AssociationReflection
+#            reflection = klass.new(macro, name, options, active_record)
+#          when :composed_of
+#            reflection = AggregateReflection.new(macro, name, options, active_record)
+#        end
+
+        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.connection = connection
+        end
+      end
+    end
+
+  end
+end
+
+
+module Ooor
+  # = Active Record Reflection
+  module Reflection # :nodoc:
+
+    class MacroReflection
+      attr_accessor :connection
+    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 ||= connection.class_name_from_model_key(class_name).constantize
+      end
+
+    end
+
+  end
+end

data/lib/{app/models → ooor}/relation.rb

@@ -1,5 +1,5 @@
 #    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2012 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-TODAY Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #    Licensed under the MIT license, see MIT-LICENSE file
 
@@ -9,16 +9,15 @@
 module Ooor
   # = Similar to Active Record Relation
   class Relation
-    
     attr_reader :klass, :loaded
-    attr_accessor :context, :count_field, :includes_values, :eager_load_values, :preload_values,
+    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
+                  :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value, :page_value, :per_value
     alias :loaded? :loaded
-    
-    def build_where(opts, other = [])
+
+    def build_where(opts, other = [])#TODO OpenERP domain is more than just the intersection of restrictions
       case opts
-      when Array
+      when Array || '|' || '&'
         [opts]
       when Hash
         opts.keys.map {|key|["#{key}", "=", opts[key]]}
@@ -27,7 +26,11 @@ module Ooor
     
     def where(opts, *rest)
       relation = clone
-      relation.where_values += build_where(opts, rest) unless opts.blank?
+      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
 
@@ -60,14 +63,13 @@ module Ooor
       calculate(:count, column_name, options)
     end
     
-    def initialize(klass)
+    def initialize(klass, options={})
       @klass = klass
       @where_values = []
       @loaded = false
-      @context = {}
+      @options = options
       @count_field = false
-      @limit_value = false
-      @offset_value = false
+      @offset_value = 0
       @order_values = []
     end
     
@@ -93,24 +95,61 @@ module Ooor
       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 TODO
-      to_a
+      args.any? ? apply_finder_options(args.first).to_a : to_a
     end
 
     def to_a
-      return @records if loaded?
-      if @order_values.empty?
-        search_order = false
+      if loaded?
+        @records
       else
-        search_order = @order_values.join(", ")
+        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|
+            r = @klass.new({name: tuple[1]}, [])
+            r.id = tuple[0]
+            r #TODO load the fields optionally
+          end
+        else
+          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,
+            })
+          @records = @klass.find(:all, opts)
+        end
       end
-      ids = @klass.rpc_execute('search', @where_values, @offset_value, @limit_value, search_order, @context, @count_field)
-      @records = @klass.find(ids)
-      @loaded = true
-      @records
     end
   
     def eager_loading?

data/lib/ooor/relation/finder_methods.rb

@@ -0,0 +1,113 @@
+require 'active_support/concern'
+
+module Ooor
+  module FinderMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def find(*arguments)
+        if arguments.size == 1 &&
+            arguments[0].is_a?(Hash) ||
+            (arguments[0].is_a?(Array) && !([arguments[0][1]] & Ooor::TypeCasting::OPERATORS).empty?)
+          find_single(nil, {domain: arguments[0]})
+        else
+          find_dispatch(*arguments)
+        end
+      end
+
+      private
+        def find_dispatch(*arguments)
+          scope   = arguments.slice!(0)
+          options = arguments.slice!(0) || {}
+          if (!scope.is_a?(Array) && !options.is_a?(Hash))
+            scope = [scope] + [options] + arguments
+            options = {}
+          end
+          case scope
+          when :all   then find_single(nil, options)
+          when :first then find_first_or_last(options)
+          when :last  then find_first_or_last(options, "DESC")
+          when :one   then find_one(options)
+          else             find_single(scope, options)
+          end
+        end
+      
+        def find_first_or_last(options, ordering = "ASC")
+          options[:order] ||= "id #{ordering}"
+          options[:limit] = 1
+          find_single(nil, options)[0]
+        end
+
+        #actually finds many resources specified with scope = ids_array
+        def find_single(scope, options)
+          context = options[:context] || {}
+          reload_fields_definition(false, context)
+          fields = options[:fields] || options[:only] || fast_fields(options)
+          fields += options[:include] if options[:include]
+          
+          if scope
+            is_collection, records = read_scope(context, fields, scope)
+          else
+            is_collection, records = read_domain(context, fields, options)
+          end
+          active_resources = []
+          records.each { |record| active_resources << new(record, [], context, true)}
+          if is_collection
+            active_resources
+          else
+            active_resources[0]
+          end
+        end
+        
+        def read_scope(context, fields, scope)
+          if scope.is_a? Array
+            is_collection = true
+          else
+            scope = [scope]
+            is_collection = false
+          end
+          scope.map! { |item| item_to_id(item, context) }.reject! {|item| !item}
+          records = rpc_execute('read', scope, fields, context.dup)
+          records.sort_by! {|r| scope.index(r["id"])} if @connection.config[:force_xml_rpc]
+          return is_collection, records
+        end
+        
+        def read_domain(context, fields, options)
+          if @connection.config[:force_xml_rpc]
+            domain = to_openerp_domain(options[:domain] || options[:conditions] || [])
+            ids = rpc_execute('search', domain, options[:offset] || 0, options[:limit] || false,  options[:order] || false, context.dup)
+            records = rpc_execute('read', ids, fields, context.dup)
+          else
+            domain = to_openerp_domain(options[:domain] || options[:conditions] || [])
+            response = object_service(:search_read, openerp_model, 'search_read', {
+                fields: fields,
+                offset: options[:offset] || 0,
+                limit: options[:limit] || false,
+                domain: domain,
+                sort: options[:order] || false,
+                context: context
+              })
+            records = response["records"]
+          end
+          return true, records
+        end
+
+        def item_to_id(item, context)
+          if item.is_a?(String)
+            if item.to_i == 0#triggers ir_model_data absolute reference lookup
+              tab = item.split(".")
+              domain = [['name', '=', tab[-1]]]
+              domain << ['module', '=', tab[-2]] if tab[-2]
+              ir_model_data = const_get('ir.model.data').find(:first, domain: domain, context: context)
+              ir_model_data && ir_model_data.res_id && search([['id', '=', ir_model_data.res_id]], 0, false, false, context)[0]
+            else
+              item.to_i
+            end
+          else
+            item
+          end
+        end
+
+    end
+  end
+end

data/lib/ooor/report.rb

@@ -0,0 +1,53 @@
+require 'active_support/concern'
+
+module Ooor
+  module Report
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      #Added methods to obtain report data for a model
+      def report(report_name, ids, report_type='pdf', context={}) #TODO move to ReportService
+        context = connection.object.inject_session_context(:report, false, context)[0]
+        uid = @connection.config[:user_id]
+        pass = @connection.config[:password]
+        db = @connection.config[:database]
+        params = {model: openerp_model, id: ids[0], report_type: report_type}
+        connection.report.report(db, uid, pass, report_name, ids, params, context)
+      end
+
+      def report_get(report_id)
+        uid = @connection.config[:user_id]
+        pass = @connection.config[:password]
+        db = @connection.config[:database]
+        connection.report.report_get(db, uid, pass, report_id)
+      end
+
+      def get_report_data(report_name, ids, report_type='pdf', context={})
+        report_id = report(report_name, ids, report_type, context)
+        if report_id
+          state = false
+          attempt = 0
+          while not state
+            report = self.report_get(report_id)
+            state = report["state"]
+            attempt = 1
+            if not state
+              sleep(0.1)
+              attempt += 1
+            else
+              return [report["result"],report["format"]]
+            end
+            if attempt > 100
+              logger.debug "OOOR RPC: 'Printing Aborted!'"
+              break
+            end
+          end
+        else
+          logger.debug "OOOR RPC: 'report not found'"
+        end
+        return nil
+      end
+
+    end
+  end
+end

data/lib/{app/models → ooor}/serialization.rb

@@ -1,25 +1,41 @@
 #    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2012 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-TODAY Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #    Licensed under the MIT license, see MIT-LICENSE file
 
 module Ooor
   module Serialization
 
+    extend ActiveSupport::Concern
+
+    included do
+      self.include_root_in_json = false
+    end
+
     def serializable_hash(options = nil)
       options ||= {}
       hash = super(options)
 
       attribute_names = attributes.keys.sort
       included_associations = {}
+      serialize_many2one(included_associations)
+      serialize_x_to_many(included_associations)
+
+      method_names = Array.wrap(options[:methods]).map { |n| n if respond_to?(n.to_s) }.compact
+      Hash[(attribute_names + method_names).map { |n| [n, send(n)] }].merge(included_associations)
+    end
+
+    def serialize_many2one(included_associations)
       self.class.many2one_associations.keys.each do |k|
-        if loaded_associations[k].is_a? OpenObjectResource
+        if loaded_associations[k].is_a? Base
           included_associations[k] = loaded_associations[k].as_json[loaded_associations[k].class.openerp_model.gsub('.', '_')]
         elsif associations[k].is_a? Array
           included_associations[k] = {"id" => associations[k][0], "name" => associations[k][1]}
         end
       end
+    end
 
+    def serialize_x_to_many(included_associations)
       (self.class.one2many_associations.keys + self.class.many2many_associations.keys).each do |k|
         if loaded_associations[k].is_a? Array
           included_associations[k] = loaded_associations[k].map {|item| item.as_json[item.class.openerp_model.gsub('.', '_')]}
@@ -27,11 +43,7 @@ module Ooor
           included_associations[k] = associations[k].map {|id| {"id" => id}} if associations[k]
         end
       end
-
-      method_names = Array.wrap(options[:methods]).map { |n| n if respond_to?(n.to_s) }.compact
-      Hash[(attribute_names + method_names).map { |n| [n, send(n)] }].merge(included_associations)
     end
 
   end
 end
-

data/lib/ooor/services.rb

@@ -0,0 +1,133 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2009-2013 Akretion LTDA (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+require 'json'
+
+module Ooor
+  autoload :InvalidSessionError, 'ooor/errors'
+
+  class Service
+    def initialize(session)
+      @session = session
+    end
+    
+    def self.define_service(service, methods)
+      methods.each do |meth|
+        self.instance_eval do
+          define_method meth do |*args|
+            endpoint = @session.get_client(:xml, "#{@session.base_url}/#{service.to_s.gsub('ooor_alias_', '')}") #TODO make that transport agnostic
+            endpoint.call(meth.gsub('ooor_alias_', ''), *args)
+          end
+        end
+      end
+    end
+  end
+
+
+  class CommonService < Service
+    define_service(:common, %w[ir_get ir_set ir_del about ooor_alias_login logout timezone_get get_available_updates get_migration_scripts get_server_environment login_message check_connectivity about get_stats list_http_services version authenticate get_available_updates set_loglevel get_os_time get_sqlcount])
+
+    def login(db, username, password)
+      @session.logger.debug "OOOR login - db: #{db}, username: #{username}"
+
+      if @session.config[:force_xml_rpc]
+        send("ooor_alias_login", db, username, password)
+      else
+        conn = @session.get_client(:json, "#{@session.base_jsonrpc2_url}")
+        response = conn.post do |req|
+          req.url '/web/session/authenticate' 
+          req.headers['Content-Type'] = 'application/json'
+          req.body = {method: 'call', params: { db: db, login: username, password: password}}.to_json
+        end
+        @session.web_session[:cookie] = response.headers["set-cookie"]
+        if response.status == 200
+          sid_part1 = @session.web_session[:cookie].split("sid=")[1]
+          if sid_part1
+            @session.web_session[:sid] = @session.web_session[:cookie].split("sid=")[1].split(";")[0] # NOTE side is required on v7 but not on v8, this enables to sniff if we are on v7
+          end
+          json_response = JSON.parse(response.body)
+          @session.web_session[:session_id] = json_response['result']['session_id']
+          user_id = json_response['result']['uid']
+          @session.config[:user_id] = user_id
+          Ooor.session_handler.register_session(@session)
+          user_id
+        else
+          raise Faraday::Error::ClientError.new(response.status, response)
+        end
+      end
+    end
+  end
+
+
+  class DbService < Service
+    define_service(:db, %w[get_progress drop dump restore rename db_exist list change_admin_password list_lang server_version migrate_databases create_database duplicate_database])
+
+    def create(password=@session.config[:db_password], db_name='ooor_test', demo=true, lang='en_US', user_password=@session.config[:password] || 'admin')
+      @session.logger.info "creating database #{db_name} this may take a while..."
+      process_id = @session.get_client(:xml, @session.base_url + "/db").call("create", password, db_name, demo, lang, user_password)
+      sleep(2)
+      while get_progress(password, process_id)[0] != 1
+        @session.logger.info "..."
+        sleep(0.5)
+      end
+      @session.global_login(username: 'admin', password: user_password, database: db_name)
+    end
+  end
+
+
+  class ObjectService < Service
+    define_service(:object, %w[execute exec_workflow])
+    
+    def object_service(service, obj, method, *args)
+      unless @session.config[:user_id]
+        @session.common.login(@session.config[:database], @session.config[:username], @session.config[:password])
+      end
+      args = inject_session_context(service, method, *args)
+      uid = @session.config[:user_id]
+      db = @session.config[:database]
+      @session.logger.debug "OOOR object service: rpc_method: #{service}, db: #{db}, uid: #{uid}, pass: #, obj: #{obj}, method: #{method}, *args: #{args.inspect}"
+      if @session.config[:force_xml_rpc]
+        pass = @session.config[:password]
+        send(service, db, uid, pass, obj, method, *args)
+      else
+        unless @session.web_session[:session_id]
+          @session.common.login(@session.config[:database], @session.config[:username], @session.config[:password])
+        end
+        json_conn = @session.get_client(:json, "#{@session.base_jsonrpc2_url}")
+        json_conn.oe_service(@session.web_session, service, obj, method, *args)
+      end
+      rescue InvalidSessionError
+        @session.config[:force_xml_rpc] = true #TODO set v6 version too
+        retry
+      rescue SessionExpiredError
+        @session.logger.debug "session for uid: #{uid} has expired, trying to login again"
+        @session.common.login(@session.config[:database], @session.config[:username], @session.config[:password])
+        retry
+    end
+
+    def inject_session_context(service, method, *args)
+      if service == :object && (i = Ooor.irregular_context_position(method)) && args.size >= i 
+        c = HashWithIndifferentAccess.new(args[i])
+        args[i] = @session.session_context(c)
+      elsif args[-1].is_a? Hash #context
+        if args[-1][:context]
+          c = HashWithIndifferentAccess.new(args[-1][:context])
+          args[-1][:context] = @session.session_context(c)
+        else
+          c = HashWithIndifferentAccess.new(args[-1])
+          args[-1] = @session.session_context(c)
+        end
+      end
+      args
+    end
+    
+  end
+
+
+  class ReportService < Service
+    define_service(:report, %w[report report_get render_report]) #TODO make use json rpc transport too
+  end
+
+end