ext_ooor 2.3.0.1

data/lib/ooor/relation/finder_methods.rb

@@ -0,0 +1,153 @@
+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)
+          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, [], true)}
+          if is_collection
+             inject_includes!(active_resources, options)
+             active_resources
+          else
+            active_resources[0]
+          end
+        end
+
+        def inject_includes!(active_resources, options)
+          (options[:includes] || []).each do |key|
+            if key.is_a?(Hash) # recursive includes
+              sub_options = key.values.first
+              if sub_options.is_a?(Array) # like Rails User.includes(:address, friends: [:address, :followers])
+                sub_options = {includes: sub_options}
+              end
+              key = key.keys.first.to_s
+            else
+              key = key.to_s
+            end
+
+            if many2one_associations.keys.include?(key)
+              filtered_ids = active_resources.map do |i|
+                val = i.associations[key]
+                val.is_a?(Array) ? val.first : val
+              end.select {|i| i} # filter out nil ids
+            elsif one2many_associations.keys.include?(key) || many2many_associations.keys.include?(key)
+              filtered_ids = active_resources.map { |i| i.associations[key]}.flatten
+            end
+
+            relation = all_fields[key]['relation']
+            records = const_get(relation).find(filtered_ids, sub_options)
+            records_hash = Hash[ *records.collect { |r| [ r.id, r ] }.flatten ]
+            if many2one_associations.keys.include?(key)
+              active_resources.each_with_index do |res|
+                val = res.associations[key]
+                rel_id = val.is_a?(Array) ? val.first : val
+                res.loaded_associations[key] = rel_id ? records_hash[rel_id] : nil
+              end
+            else # one2many and many2many
+              active_resources.each_with_index do |res|
+                rel_ids = res.associations[key]
+                res.loaded_associations[key] = rel_ids.map { |i| records_hash[i] }
+              end
+            end
+          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 @session.config[:force_xml_rpc]
+          return is_collection, records
+        end
+
+        def read_domain(context, fields, options)
+          if @session.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 = session.object.inject_session_context(:report, false, context)[0]
+        uid = @session.config[:user_id]
+        pass = @session.config[:password]
+        db = @session.config[:database]
+        params = {model: openerp_model, id: ids[0], report_type: report_type}
+        session.report.report(db, uid, pass, report_name, ids, params, context)
+      end
+
+      def report_get(report_id)
+        uid = @session.config[:user_id]
+        pass = @session.config[:password]
+        db = @session.config[:database]
+        session.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/ooor/serialization.rb

@@ -0,0 +1,49 @@
+#    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
+
+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? 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('.', '_')]}
+        else
+          included_associations[k] = associations[k].map {|id| {"id" => id}} if associations[k]
+        end
+      end
+    end
+
+  end
+end

data/lib/ooor/services.rb

@@ -0,0 +1,134 @@
+#    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
+
+    # using define_method provides handy autocompletion
+    def self.define_service(service, methods)
+      methods.each do |meth|
+        self.instance_eval do
+          define_method meth do |*args|
+            if @session.odoo_serie > 7
+              json_conn = @session.get_client(:json, "#{@session.base_jsonrpc2_url}")
+              json_conn.oe_service(@session.web_session, service, nil, meth, *args)
+            else # via XMLRPC on v7:
+              endpoint = @session.get_client(:xml, "#{@session.base_url}/#{service.to_s.gsub('ooor_alias_', '')}")
+              endpoint.call(meth.gsub('ooor_alias_', ''), *args)
+            end
+          end
+        end
+      end
+    end
+  end
+
+
+  class CommonService < Service
+    define_service(:common, %w[ir_get ir_set ir_del about 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 csrf_token()
+      unless defined?(Nokogiri)
+        raise "You need to install the nokogiri gem for this feature"
+      end
+      require 'nokogiri'
+      @session.logger.debug "OOOR csrf_token"
+      conn = @session.get_client(:json, "#{@session.base_jsonrpc2_url}")
+    	login_page = conn.get('/web/login') do |req|
+        req.headers['Cookie'] = "session_id=#{@session.web_session[:session_id]}"
+      end.body # TODO implement some caching
+      Nokogiri::HTML(login_page).css("input[name='csrf_token']")[0]['value']
+    end
+
+    private
+    # Function to validate json response with useful messages
+    # Eg: For Database database "<DB NAME>" does not exist errors from open erb.
+    def validate_response(json_response)
+      error = json_response["error"]
+
+      if error && (error["data"]["type"] == "server_exception" || error['message'] == "Odoo Server Error")
+        raise "#{error["message"]} ------- #{error["data"]["debug"]}"
+      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')
+      if @session.odoo_serie > 7
+        json_conn = @session.get_client(:json, "#{@session.base_jsonrpc2_url}")
+        x = json_conn.oe_service(@session.web_session, :db, nil, 'create_database', password, db_name, demo, lang, user_password)
+      else # via XMLRPC on v7:
+        @session.logger.info "creating database #{db_name} this may take a while..."
+        process_id = @session.get_client(:xml, @session.base_url + "/db").call("create_database", password, db_name, demo, lang, user_password)
+        sleep(2)
+        while process_id.is_a?(Integer) && get_progress(password, process_id)[0] != 1
+          @session.logger.info "..."
+          sleep(0.5)
+        end
+      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)
+      @session.login_if_required()
+      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
+        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.login(@session.config[:database], @session.config[:username], @session.config[:password])
+        retry # TODO put a retry limit to avoid infinite login attempts
+    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

data/lib/ooor/session.rb

@@ -0,0 +1,250 @@
+require 'ooor/services'
+require 'active_support/configurable'
+require 'active_support/core_ext/hash/slice'
+
+
+module Ooor
+  class Session
+    include ActiveSupport::Configurable
+    include Transport
+
+    attr_accessor :web_session, :id, :models
+
+    def common(); @common_service ||= CommonService.new(self); end
+    def db(); @db_service ||= DbService.new(self); end
+    def object(); @object_service ||= ObjectService.new(self); end
+    def report(); @report_service ||= ReportService.new(self); end
+
+
+    def public_controller_method(path, query_values={})
+      unless defined?(Addressable)
+        raise "You need to install the addressable gem for this feature"
+      end
+      require 'addressable/uri'
+      login_if_required()
+      conn = get_client(:json, "#{base_jsonrpc2_url}")
+      conn.post do |req|
+        req.url path
+        req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        req.headers['Cookie'] = "session_id=#{web_session[:session_id]}"
+        uri = Addressable::URI.new
+        uri.query_values = query_values
+        req.body = uri.query
+      end
+    end
+
+    def initialize(config, web_session, id)
+      set_config(HashWithIndifferentAccess.new(config))
+      Object.const_set(config[:scope_prefix], Module.new) if config[:scope_prefix]
+      @models = {}
+      @local_context = {}
+      @web_session = web_session || {}
+      @id = id || web_session[:session_id]
+      Ooor.session_handler.register_session(self)
+    end
+
+    def login_if_required
+      if !config[:user_id] || !web_session[:session_id]
+        login(config[:database], config[:username], config[:password], config[:params])
+      end
+    end
+
+    def login(db, username, password, kw={})
+      logger.debug "OOOR login - db: #{db}, username: #{username}"
+      raise "Cannot login without specifying a database" unless db
+      raise "Cannot login without specifying a username" unless username
+      raise "Cannot login without specifying a password" unless password
+      if config[:force_xml_rpc]
+        send("ooor_alias_login", db, username, password)
+      else
+        conn = get_client(:json, "#{self.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, base_location: kw}}.to_json
+        end
+        web_session[:cookie] = response.headers["set-cookie"]
+        json_response = JSON.parse(response.body)
+        error = json_response["error"]
+        if error && (error["data"]["type"] == "server_exception" || error['message'] == "Odoo Server Error")
+          raise "#{error['message']} ------- #{error['data']['debug']}"
+        elsif response.status == 200
+          if sid_part1 = web_session[:cookie].split("sid=")[1]
+            # required on v7 but not on v8+, this enables us to sniff if we are on v7
+            web_session[:sid] = web_session[:cookie].split("sid=")[1].split(";")[0]
+          end
+
+          web_session[:session_id] = json_response['result']['session_id']
+
+          user_id = json_response['result'].delete('uid')
+          config[:user_id] = user_id
+          web_session.merge!(json_response['result'].delete('user_context'))
+          set_config(json_response['result'])
+          Ooor.session_handler.register_session(self)
+          user_id
+        else
+          raise Faraday::Error::ClientError.new(response.status, response)
+        end
+      end
+    end
+
+    def set_config(configuration)
+      configuration.each do |k, v|
+        config.send "#{k}=", v
+      end
+    end
+
+    # a part of the config that will be mixed in the context of each session
+    def connection_session
+      HashWithIndifferentAccess.new(config[:connection_session] || {})
+    end
+
+    def [](key)
+      self[key]
+    end
+
+    def []=(key, value)
+      self[key] = value
+    end
+
+    def global_login(options={})
+      set_config(options)
+      load_models(config[:models], config[:reload])
+    end
+
+    def with_context(context)
+      @local_context = context
+      yield
+      @local_context = {}
+    end
+
+    def session_context(context={})
+      connection_session.merge(web_session.slice('lang', 'tz')).merge(@local_context).merge(context) # not just lang and tz?
+    end
+
+    def const_get(model_key, lang=nil);
+      if config[:aliases]
+        if lang && alias_data = config[:aliases][lang]
+          openerp_model = alias_data[model_key] || model_key
+        elsif alias_data = config[:aliases][connection_session['lang'] || :en_US]
+          openerp_model = alias_data[model_key] || model_key
+        else
+          openerp_model = model_key
+        end
+      else
+        openerp_model = model_key
+      end
+      define_openerp_model(model: openerp_model, scope_prefix: config[:scope_prefix], generate_constants: config[:generate_constants])
+    end
+
+    def[](model_key) #TODO invert: define method here and use []
+      const_get(model_key)
+    end
+
+    def load_models(model_names=config[:models], reload=config[:reload])
+      helper_paths.each do |dir|
+        ::Dir[dir].each { |file| require file }
+      end
+      search_domain = model_names ? [['model', 'in', model_names]] : []
+      models_records = read_model_data(search_domain)
+      models_records.reject {|opts| opts['model'] == '_unknown' }.each do |opts|
+        options = HashWithIndifferentAccess.new(opts.merge(scope_prefix: config[:scope_prefix],
+                                                           reload: reload,
+                                                           generate_constants: config[:generate_constants]))
+        define_openerp_model(options)
+      end
+    end
+
+    def read_model_data(search_domain)
+      if config[:force_xml_rpc]
+        model_ids = object.object_service(:execute, "ir.model", :search, search_domain, 0, false, false, {}, false)
+        models_records = object.object_service(:execute, "ir.model", :read, model_ids, ['model', 'name'])
+      else
+        response = object.object_service(:search_read, "ir.model", 'search_read',
+                fields: ['model', 'name'],
+                offset: 0,
+                limit: false,
+                domain: search_domain,
+                sort: false,
+                context: {})
+        models_records = response["records"]
+      end
+    end
+
+    def set_model_template!(klass, options)
+      template = Ooor.model_registry.get_template(config, options[:model])
+      if template
+        klass.t = template
+      else
+        template = Ooor::ModelSchema.new
+        template.openerp_model = options[:model]
+        template.openerp_id = options[:id]
+        template.description = options[:name]
+        template.state = options[:state]
+        template.many2one_associations = {}
+        template.one2many_associations = {}
+        template.many2many_associations = {}
+        template.polymorphic_m2o_associations = {}
+        template.associations_keys = []
+        klass.t = template
+      end
+    end
+
+    def define_openerp_model(options) #TODO param to tell if we define constants or not
+      if !models[options[:model]] || options[:reload]# || !scope.const_defined?(model_class_name)
+        scope_prefix = options[:scope_prefix]
+        scope = scope_prefix ? Object.const_get(scope_prefix) : Object
+        model_class_name = class_name_from_model_key(options[:model])
+        logger.debug "registering #{model_class_name}"
+        klass = Class.new(Base)
+        set_model_template!(klass, options)
+        klass.name = model_class_name
+        klass.scope_prefix = scope_prefix
+        klass.session = self
+        if options[:generate_constants] && (options[:reload] || !scope.const_defined?(model_class_name))
+          scope.const_set(model_class_name, klass)
+        end
+        (Ooor.extensions[options[:model]] || []).each do |block|
+          klass.class_eval(&block)
+        end
+        models[options[:model]] = klass
+      end
+      models[options[:model]]
+    end
+
+#    def models; @models ||= {}; end
+
+    def logger; Ooor.logger; end
+
+    def helper_paths
+      [File.dirname(__FILE__) + '/helpers/*', *config[:helper_paths]]
+    end
+
+    def class_name_from_model_key(model_key)
+      model_key.split('.').collect {|name_part| name_part.capitalize}.join
+    end
+
+    def odoo_serie
+      if config.user_id # authenticated session
+        if config[:server_version_info] # v10 and onward
+          config[:server_version_info][0]
+        elsif config['partner_id']
+          9
+        elsif web_session[:sid]
+          7
+        else
+          8
+        end
+      else
+        json_conn = get_client(:json, base_jsonrpc2_url)
+        begin
+          @version_info ||= json_conn.oe_service(web_session, "/web/webclient/version_info", nil, nil, [])
+          @version_info['server_serie'].to_i
+        rescue # Odoo v7 doesn't have this version info service
+          7
+        end
+      end
+    end
+
+  end
+end