ext_ooor 2.3.0.1

data/lib/ooor/session_handler.rb

@@ -0,0 +1,66 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'ooor/session'
+
+module Ooor
+  autoload :SecureRandom, 'securerandom'
+  # The SessionHandler allows to retrieve a session with its loaded proxies to OpenERP
+  class SessionHandler
+
+    def noweb_session_spec(config)
+      "#{config[:url]}-#{config[:database]}-#{config[:username]}"
+    end
+
+    def retrieve_session(config, id=nil, web_session={})
+      id ||= SecureRandom.hex(16)
+      if id == :noweb
+        spec = noweb_session_spec(config)
+      else
+        spec = id
+      end
+
+      s = sessions[spec]
+      # reload session or create a new one if no matching session found
+      if config[:reload] || !s
+        config = Ooor.default_config.merge(config) if Ooor.default_config.is_a? Hash
+        Ooor::Session.new(config, web_session, id)
+
+      # found but config mismatch still
+      elsif noweb_session_spec(s.config) != noweb_session_spec(config)
+        config = Ooor.default_config.merge(config) if Ooor.default_config.is_a? Hash
+        Ooor::Session.new(config, web_session, id)
+
+      # matching session, update web_session of it eventually
+      else
+        s.tap {|s| s.web_session.merge!(web_session)} #TODO merge config also?
+      end
+    end
+
+    def register_session(session)
+      if session.config[:session_sharing]
+        spec = session.web_session[:session_id]
+      elsif session.id != :noweb
+        spec = session.id
+      else
+        spec = noweb_session_spec(session.config)
+      end
+      set_web_session(spec, session.web_session)
+      sessions[spec] = session
+    end
+
+    def reset!
+      @sessions = {}
+      @connections = {}
+    end
+
+    def get_web_session(key)
+      Ooor.cache.read(key)
+    end
+
+    def set_web_session(key, web_session)
+      Ooor.cache.write(key, web_session)
+    end
+
+    def sessions; @sessions ||= {}; end
+    def connections; @connections ||= {}; end
+  end
+end

data/lib/ooor/transport.rb

@@ -0,0 +1,34 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2013 Akretion LTDA (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+require 'active_support/dependencies/autoload'
+
+module Ooor
+  module Transport
+    extend ActiveSupport::Autoload
+    autoload :XmlRpcClient
+    autoload :JsonClient
+
+    def get_client(type, url)
+      case type
+      when :json
+        Thread.current[:json_clients] ||= {}
+        Thread.current[:json_clients][url] ||= JsonClient.new(url, :request => { timeout: config[:rpc_timeout] || 900 })
+      when :xml
+        Thread.current[:xml_clients] ||= {}
+        Thread.current[:xml_clients][url] ||= XmlRpcClient.new2(url, nil, config[:rpc_timeout] || 900)
+      end
+    end
+
+    def base_url
+      @base_url ||= config[:url] = "#{config[:url].gsub(/\/$/,'').chomp('/xmlrpc')}/xmlrpc"
+    end
+
+    def base_jsonrpc2_url
+      @base_jsonrpc2_url ||= config[:url].gsub(/\/$/,'').chomp('/xmlrpc')
+    end
+
+  end
+end

data/lib/ooor/transport/json_client.rb

@@ -0,0 +1,65 @@
+require 'faraday'
+
+module Ooor
+  module Transport
+    module JsonClient
+      module OeAdapter # NOTE use a middleware here?
+
+        def oe_service(session_info, service, obj, method, *args)
+          if service == :exec_workflow
+            url = '/web/dataset/exec_workflow'
+            params = {"model"=>obj, "id"=>args[0], "signal"=>method}
+          elsif service == :db || service == :common
+            url = '/jsonrpc'
+            params = {"service"=> service, "method"=> method, "args"=> args}
+          elsif service == :execute
+            url = '/web/dataset/call_kw'
+            if (i = Ooor.irregular_context_position(method)) && args.size < i
+              kwargs = {"context"=> args[i]}
+            else
+              kwargs = {}
+            end
+            params = {"model"=>obj, "method"=> method, "kwargs"=> kwargs, "args"=>args}#, "context"=>context}
+          elsif service.to_s.start_with?("/") # assuming service URL is forced
+            url = service
+            params = args[0]
+          else
+            url = "/web/dataset/#{service}"
+            params = args[0].merge({"model"=>obj})
+          end # TODO reports for version > 7
+          oe_request(session_info, url, params, method, *args)
+        end
+
+        def oe_request(session_info, url, params, method, *args)
+          if session_info[:req_id]
+             session_info[:req_id] += 1
+          else
+             session_info[:req_id] = 1
+          end
+          if session_info[:sid] # required on v7 but forbidden in v8
+            params.merge!({"session_id" => session_info[:session_id]})
+          end
+          response = JSON.parse(post do |req|
+            req.headers['Cookie'] = session_info[:cookie] if session_info[:cookie]
+            req.url url
+            req.headers['Content-Type'] = 'application/json'
+            req.body = {"jsonrpc"=>"2.0","method"=>"call", "params" => params, "id"=>session_info[:req_id]}.to_json
+          end.body)
+          if response["error"]
+            faultCode = response["error"]['data']['fault_code'] || response["error"]['data']['debug']
+            raise OpenERPServerError.build(faultCode, response["error"]['message'], method, *args)
+          else
+            response["result"]
+          end
+        end
+      end
+
+      Faraday::Connection.send :include, OeAdapter
+
+      def self.new(url, options = {})
+        options[:ssl] = {:verify => false}
+        Faraday.new(url, options) # TODO use middlewares
+      end
+    end
+  end
+end

data/lib/ooor/transport/xml_rpc_client.rb

@@ -0,0 +1,15 @@
+require 'xmlrpc/client'
+
+module Ooor
+  module Transport
+    class XmlRpcClient < XMLRPC::Client
+      def call2(method, *args)
+        request = create().methodCall(method, *args)
+        data = (["<?xml version='1.0' encoding='UTF-8'?>\n"] + do_rpc(request, false).lines.to_a[1..-1]).join  #encoding is not defined by OpenERP and can lead to bug with Ruby 1.9
+        parser().parseMethodResponse(data)
+      rescue RuntimeError => e
+        raise OpenERPServerError.create_from_trace(e, method, *args)
+      end
+    end
+  end
+end

data/lib/ooor/type_casting.rb

@@ -0,0 +1,223 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2009-2014 Akretion LTDA (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+module Ooor
+  module TypeCasting
+    extend ActiveSupport::Concern
+
+    OPERATORS = ["=", "!=", "<=", "<", ">", ">=", "=?", "=like", "=ilike", "like", "not like", "ilike", "not ilike", "in", "not in", "child_of"]
+    BLACKLIST = %w[id write_date create_date write_ui create_ui]
+
+    module ClassMethods
+
+      def openerp_string_domain_to_ruby(string_domain) #FIXME: used? broken?
+        eval(string_domain.gsub('(', '[').gsub(')',']'))
+      end
+
+      def to_openerp_domain(domain)
+        if domain.is_a?(Hash)
+          return domain.map{|k,v| [k.to_s, '=', v]}
+        elsif domain == []
+          return []
+        elsif domain.is_a?(Array) && !domain.last.is_a?(Array)
+          return [domain]
+        else
+          return domain
+        end
+      end
+
+      def to_rails_type(type)
+        case type.to_sym
+        when :char
+          :string
+        when :binary
+          :file
+        when :many2one
+          :belongs_to
+        when :one2many
+          :has_many
+        when :many2many
+          :has_and_belongs_to_many
+        else
+          type.to_sym
+        end
+      end
+
+      def value_to_openerp(v)
+        if v == nil || v == ""
+          return false
+        elsif !v.is_a?(Integer) && !v.is_a?(Float) && v.is_a?(Numeric) && v.respond_to?(:to_f)
+          return v.to_f
+        elsif !v.is_a?(Numeric) && !v.is_a?(Integer) && v.respond_to?(:sec) && v.respond_to?(:year)#really ensure that's a datetime type
+          return "%d-%02d-%02d %02d:%02d:%02d" % [v.year, v.month, v.day, v.hour, v.min, v.sec]
+        elsif !v.is_a?(Numeric) && !v.is_a?(Integer) && v.respond_to?(:day) && v.respond_to?(:year)#really ensure that's a date type
+          return "%d-%02d-%02d" % [v.year, v.month, v.day]
+        elsif v == "false" #may happen with OOORBIT
+          return false
+        elsif v.respond_to?(:read)
+          return Base64.encode64(v.read())
+        else
+          v
+        end
+      end
+
+      def cast_request_to_openerp(request)
+        if request.is_a?(Array)
+          request.map { |item| cast_request_to_openerp(item) }
+        elsif request.is_a?(Hash)
+          request2 = {}
+          request.each do |k, v|
+            request2[k] = cast_request_to_openerp(v)
+          end
+        else
+          value_to_openerp(request)
+        end
+      end
+
+      def cast_answer_to_ruby!(answer)
+        def cast_map_to_ruby!(map)
+          map.each do |k, v|
+            if self.t.fields[k] && v.is_a?(String) && !v.empty?
+              case self.t.fields[k]['type']
+              when 'datetime'
+                map[k] = DateTime.parse(v)
+              when 'date'
+                map[k] = Date.parse(v)
+              end
+            end
+          end
+        end
+
+        if answer.is_a?(Array)
+          answer.each {|item| self.cast_map_to_ruby!(item) if item.is_a? Hash}
+        elsif answer.is_a?(Hash)
+          self.cast_map_to_ruby!(answer)
+        else
+          answer
+        end
+      end
+
+    end
+
+    def sanitize_attribute(skey, value)
+      type = self.class.fields[skey]['type']
+      if type == 'boolean' && (value == 1 || value == "1")
+        true
+      elsif type == 'boolean'&& (value == 0 || value == "0")
+        false
+      elsif value == false && type != 'boolean'
+        nil
+      elsif (type == 'char' || type == 'text') && value == "" && @attributes[skey] == nil
+        nil
+      else
+        value
+      end
+    end
+
+    def sanitize_association(skey, value)
+      if value.is_a?(Ooor::Base) || value.is_a?(Array) && value.all? {|i| i.is_a?(Ooor::Base)}
+        value
+      elsif value.is_a?(Array) && !self.class.many2one_associations.keys.index(skey)
+        value.reject {|i| i == ''}.map {|i| i.is_a?(String) ? i.to_i : i}
+      elsif value.is_a?(String)
+        sanitize_association_as_string(skey, value)
+      else
+        value
+      end
+    end
+
+    def sanitize_association_as_string(skey, value)
+      if self.class.polymorphic_m2o_associations.has_key?(skey)
+        value
+      elsif self.class.many2one_associations.has_key?(skey)
+        sanitize_m2o_association(value)
+      else
+        value.split(",").map {|i| i.to_i}
+      end
+    end
+
+    def sanitize_m2o_association(value)
+      if value.blank? || value == "0"
+        false
+      else
+        value.to_i
+      end
+    end
+
+    def to_openerp_hash
+      attribute_keys, association_keys = get_changed_values
+      associations = {}
+      association_keys.each { |k| associations[k] = self.cast_association(k) }
+      @attributes.slice(*attribute_keys).merge(associations)
+    end
+
+    def get_changed_values
+      attribute_keys = changed.select {|k| self.class.fields.has_key?(k)} - BLACKLIST
+      association_keys = changed.select {|k| self.class.associations_keys.index(k)}
+      return attribute_keys, association_keys
+    end
+
+    # talk OpenERP cryptic associations API
+    def cast_association(k)
+      if self.class.one2many_associations[k]
+        if @loaded_associations[k]
+          v = @loaded_associations[k].select {|i| i.changed?}
+          v = @associations[k] if v.empty?
+        else
+          v = @associations[k]
+        end
+        cast_o2m_association(v)
+      elsif self.class.many2many_associations[k]
+        v = @associations[k]
+        [[6, false, (v || []).map {|i| i.is_a?(Base) ? i.id : i}]]
+      elsif self.class.many2one_associations[k]
+        v = @associations[k] # TODO support for nested
+        cast_m2o_association(v)
+      end
+    end
+
+    def cast_o2m_association(v)
+      v.collect do |value|
+        if value.is_a?(Base)
+          if value.new_record?
+            [0, 0, value.to_openerp_hash]
+          elsif value.marked_for_destruction?
+            [2, value.id]
+          elsif value.id
+            [1, value.id , value.to_openerp_hash]
+          end
+        elsif value.is_a?(Hash)
+          [0, 0, value]
+        else #use case?
+          [1, value, {}]
+        end
+      end
+    end
+
+    def cast_o2m_nested_attributes(v)
+      v.keys.collect do |key|
+        val = v[key]
+        if !val["_destroy"].blank?
+          [2, val[:id].to_i || val['id']]
+        elsif val[:id] || val['id']
+          [1, val[:id].to_i || val['id'], val]
+        else
+          [0, 0, val]
+        end
+      end
+    end
+
+    def cast_m2o_association(v)
+      if v.is_a?(Array)
+        v[0]
+      elsif v.is_a?(Base)
+        v.id
+      else
+        v
+      end
+    end
+
+  end
+end

data/lib/ooor/version.rb

@@ -0,0 +1,8 @@
+module Ooor
+  MAJOR = 2
+  MINOR = 3
+  TINY  = 0
+  PRE   = nil
+
+  VERSION = [MAJOR, MINOR, TINY].compact.join('.')
+end

data/spec/cli_spec.rb

@@ -0,0 +1,129 @@
+#    Copyright (C) 2017 Akretion (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+if ENV["CI"]
+  require 'coveralls'
+  Coveralls.wear!
+end
+require File.dirname(__FILE__) + '/../lib/ooor'
+
+OOOR_URL = ENV['OOOR_URL'] || 'http://localhost:8069'
+OOOR_DB_PASSWORD = ENV['OOOR_DB_PASSWORD'] || 'admin'
+OOOR_USERNAME = ENV['OOOR_USERNAME'] || 'admin'
+OOOR_PASSWORD = ENV['OOOR_PASSWORD'] || 'admin'
+OOOR_DATABASE = ENV['OOOR_DATABASE'] || 'ooor_test'
+OOOR_ODOO_VERSION = ENV['VERSION'] || '10.0'
+
+
+# Note: we never set both teh password and the database to avoid invalid logins here
+describe "ooor CLI" do
+
+  before do
+    ENV['OOOR_URL'] = nil # removed to avoid conflicting with Ooor.new tests
+    ENV['OOOR_DATABASE'] = nil
+  end
+
+  after do
+   ENV['OOOR_URL'] = OOOR_URL
+   ENV['OOOR_DATABASE'] = OOOR_DATABASE
+  end
+
+  describe "ooor 2.x legacy format" do
+    it "should parse user.mydb@myhost:8089" do
+      Ooor.new("user.mydb@myhost:8089")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.database).to eq 'mydb'
+      expect(s.config.url).to eq 'http://myhost:8089'
+    end
+
+    it "should parse user.mydb@myhost:443" do
+      Ooor.new("user.mydb@myhost:443")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.database).to eq 'mydb'
+      expect(s.config.url).to eq 'https://myhost:443'
+    end
+
+    it "should parse user.mydb@myhost:8089 -s" do
+      Ooor.new("user.mydb@myhost:8089 -s")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.database).to eq 'mydb'
+      expect(s.config.url).to eq 'https://myhost:8089'
+    end
+  end
+
+
+  describe "new connection string format" do
+    it "ooor://user@myhost" do
+      Ooor.new("ooor://user@myhost")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.url).to eq 'http://myhost:80'
+    end
+
+    it "ooor://user@myhost:8089" do
+      Ooor.new("ooor://user@myhost:8089")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.url).to eq 'http://myhost:8089'
+    end
+
+    it "ooor://user:secret@myhost" do
+      Ooor.session_handler.reset!
+      Ooor.new("ooor://user:secret@myhost")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.password).to eq 'secret'
+      expect(s.config.url).to eq 'http://myhost:80'
+    end
+
+    it "ooor://user:secret@myhost/mydb" do
+      Ooor.session_handler.reset!
+      config = Ooor.format_config("ooor://user:secret@myhost/mydb")
+      expect(config[:username]).to eq 'user'
+      expect(config[:password]).to eq 'secret'
+      expect(config[:database]).to eq 'mydb'
+      expect(config[:url]).to eq 'http://myhost:80'
+    end
+
+    it "ooor://user:secret@myhost:8089" do
+      Ooor.session_handler.reset!
+      Ooor.new("ooor://user:secret@myhost:8089")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.password).to eq 'secret'
+      expect(s.config.url).to eq 'http://myhost:8089'
+    end
+
+    it "ooor://user@myhost:8089/mydb" do
+      Ooor.session_handler.reset!
+      Ooor.new("ooor://user@myhost:8089/mydb")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.database).to eq 'mydb'
+      expect(s.config.url).to eq 'http://myhost:8089'
+    end
+
+    it "user:secret@myhost:8089" do
+      Ooor.session_handler.reset!
+      Ooor.new("user:secret@myhost:8089")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'user'
+      expect(s.config.password).to eq 'secret'
+      expect(s.config.url).to eq 'http://myhost:8089'
+    end
+
+    it "ooor://myhost.com:8089/mydb?ssl=true" do
+      Ooor.session_handler.reset!
+      Ooor.new("ooor://myhost.com:8089/mydb?ssl=true")
+      s = Ooor.default_session
+      expect(s.config.username).to eq 'admin'
+      expect(s.config.database).to eq 'mydb'
+      expect(s.config.url).to eq 'https://myhost.com:8089'
+    end
+
+  end
+end