ooor 1.9.2 → 2.0.0

data/lib/ooor/session.rb

@@ -0,0 +1,120 @@
+require 'ooor/services'
+
+module Ooor
+  class Session < SimpleDelegator
+    include Transport
+
+    attr_accessor :web_session, :connection, :id
+
+    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 initialize(connection, web_session, id)
+      super(connection)
+      @connection = connection
+      @web_session = web_session || {}
+      @id = id || web_session[:session_id]
+    end
+
+    def [](key)
+      @session[key]
+    end
+
+    def []=(key, value)
+      @session[key] = value
+    end
+
+    def global_login(options)
+      config.merge!(options)
+      load_models(config[:models], options[:reload])
+    end
+
+    def session_context(context={})
+      connection_session.merge(web_session.slice('lang', 'tz')).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
+      domain = model_names ? [['model', 'in', model_names]] : []
+      search_domain = domain - [1]
+      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']) #TODO use search_read
+      models_records.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 set_model_template!(klass, options)
+      template = Ooor.model_registry.get_template(config, options[:model])
+      if template
+        klass.t = template
+        klass.one2many_associations.keys.each do |meth|
+          klass.define_nested_attributes_method(meth)
+        end
+      else
+        template = Ooor::ModelTemplate.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.connection = 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
+
+  end
+end

data/lib/ooor/session_handler.rb

@@ -0,0 +1,63 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'ooor/session'
+require 'ooor/connection'
+
+module Ooor
+  autoload :SecureRandom, 'securerandom'
+  class SessionHandler
+    def connection_spec(config)
+      HashWithIndifferentAccess.new(config.slice(:url, :username, :password, :database, :scope_prefix, :helper_paths)) #TODO should really password be part of it?
+    end
+
+    def retrieve_session(config, id=nil, web_session={})
+      id ||= SecureRandom.hex(16)
+      if config[:reload] || !s = sessions[id]
+        create_new_session(config, web_session, id)
+      else
+        s.tap {|s| s.web_session.merge!(web_session)} #TODO merge config also?
+      end
+    end
+
+    def create_new_session(config, web_session, id=nil)
+      c_spec = connection_spec(config)
+      if connections[c_spec]
+        Ooor::Session.new(connections[c_spec], web_session, id)
+      else
+        Ooor::Session.new(create_new_connection(config, c_spec), web_session, id).tap do |s|
+          connections[c_spec] = s.connection
+        end
+      end
+    end
+
+    def register_session(session)
+      if session.config[:session_sharing]
+        spec = session.web_session[:session_id]
+      else
+        spec= session.id
+      end
+      set_web_session(spec, session.web_session)
+      sessions[spec] = session
+    end
+
+    def create_new_connection(config, spec)
+      config = Ooor.default_config.merge(config) if Ooor.default_config.is_a? Hash
+      Connection.new(config)
+    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
+        @json_clients ||= {}
+        @json_clients[url] ||= JsonClient.new(url: url)#, timeout: config[:rpc_timeout] || 900) #TODO timeout doesn't work depending on Faraday versions?
+      when :xml
+        @xml_clients ||= {}
+        @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,53 @@
+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 == :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}
+          else
+            url = "/web/dataset/#{service}"
+            params = args[0].merge({"model"=>obj})
+          end
+          oe_request(session_info, url, params, method, *args)
+        end
+
+        def oe_request(session_info, url, params, method, *args)
+          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]
+            req.url url
+            req.headers['Content-Type'] = 'application/json'
+            req.body = {"jsonrpc"=>"2.0","method"=>"call", "params" => params, "id"=>"r42"}.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 = nil, options = nil)
+        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,193 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2009-2012 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"]
+  
+    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|
+
+            if k.to_s.end_with?("_attributes")
+              attrs = []
+              if v.is_a?(Hash)
+                v.each do |key, val|
+                  if !val["_destroy"].empty?
+                    attrs << [2, val[:id] || val['id']]
+                  elsif val[:id] || val['id']
+                    attrs << [1, val[:id] || val['id'], cast_request_to_openerp(val)]
+                  else
+                    attrs << [0, 0, cast_request_to_openerp(val)]
+                  end
+                end
+              end
+
+              request2[k.to_s.gsub("_attributes", "")] = attrs
+            else
+              request2[k] = cast_request_to_openerp(v)
+            end
+          end
+          request2
+
+        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 to_openerp_hash(attributes=@attributes, associations=@associations)
+      associations = cast_relations_to_openerp(associations)
+      blacklist = %w[id write_date create_date write_ui create_ui]
+      r = {}
+      attributes.reject {|k, v| blacklist.index(k)}.merge(associations).each do |k, v|
+        if k.end_with?("_id") && !self.class.associations_keys.index(k) && self.class.associations_keys.index(k.gsub(/_id$/, ""))
+          r[k.gsub(/_id$/, "")] = v && v.to_i || v
+        else
+          r[k] = v
+        end
+      end
+      r
+    end
+    
+    def cast_relations_to_openerp(associations=@associations)
+      associations2 = {}
+      associations.each do |k, v|
+        if k.match(/_ids$/) && !self.class.associations_keys.index(k) && self.class.associations_keys.index(rel = k.gsub(/_ids$/, ""))
+          if v.is_a? Array
+           v.reject! {|i| i == ''}.map! {|i| i.to_i}
+          end
+          associations2[rel] = v
+        elsif v.is_a?(Array) && (v.size == 0 or v[1].is_a?(String)) #reject non assigned many2one or empty list
+         next
+        else
+          if k.end_with?("_ids") && v.is_a?(String)
+            v = v.split(",").map{|i| i.to_i}
+          end
+          associations2[k] = v
+        end
+      end
+
+      associations2.each do |k, v| #see OpenERP awkward associations API
+        #already casted, possibly before server error!
+        next if (v.is_a?(Array) && v.size == 1 && v[0].is_a?(Array)) \
+                || self.class.many2one_associations[k] \
+                || !v.is_a?(Array)
+        new_rel = self.cast_relation(k, v, self.class.one2many_associations, self.class.many2many_associations)
+        if new_rel #matches a known o2m or m2m
+          associations2[k] = new_rel
+        else
+          self.class.many2one_associations.each do |k2, field| #try to cast the association to an inherited o2m or m2m:
+            linked_class = self.class.const_get(field['relation'])
+            new_rel = self.cast_relation(k, v, linked_class.one2many_associations, linked_class.many2many_associations)
+            associations2[k] = new_rel and break if new_rel
+          end
+        end
+      end
+      associations2
+    end
+
+    def cast_relation(k, v, one2many_associations, many2many_associations)
+      if one2many_associations[k]
+        return v.collect do |value|
+          if value.is_a?(Base) #on the fly creation as in the GTK client
+            [0, 0, value.to_openerp_hash]
+          else
+            if value.is_a?(Hash)
+              [0, 0, value]
+            else
+              [1, value, {}]
+            end
+          end
+        end
+      elsif many2many_associations[k]
+        return v = [[6, 0, v]]
+      end
+    end
+ 
+  end
+end