ooor 1.9.2 → 2.0.0

data/lib/ooor/base.rb

@@ -0,0 +1,218 @@
+#    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 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/module/delegation.rb'
+require 'ooor/reflection'
+require 'ooor/reflection_ooor'
+
+module Ooor
+  class ModelTemplate #meta data shared across sessions
+    TEMPLATE_PROPERTIES = [:openerp_id, :info, :access_ids, :description,
+      :openerp_model, :field_ids, :state, :fields,
+      :many2one_associations, :one2many_associations, :many2many_associations, :polymorphic_m2o_associations, :associations_keys,
+      :associations, :columns, :columns_hash]
+    attr_accessor *TEMPLATE_PROPERTIES
+  end
+
+
+  class Base < Ooor::MiniActiveResource
+    #PREDEFINED_INHERITS = {'product.product' => 'product_tmpl_id'}
+    include Naming, TypeCasting, Serialization, ReflectionOoor, Reflection, Associations, Report, FinderMethods, FieldMethods
+
+
+    # ********************** class methods ************************************
+    class << self
+
+      attr_accessor  :name, :connection, :t, :scope_prefix #template
+      delegate *ModelTemplate::TEMPLATE_PROPERTIES, to: :t
+
+      # ******************** remote communication *****************************
+
+      def create(attributes = {}, context={}, default_get_list=false, reload=true)
+        self.new(attributes, default_get_list, context).tap { |resource| resource.save(context, reload) }
+      end
+
+      #OpenERP search method
+      def search(domain=[], offset=0, limit=false, order=false, context={}, count=false)
+        rpc_execute(:search, to_openerp_domain(domain), offset, limit, order, context, count)
+      end
+
+      def name_search(name='', domain=[], operator='ilike', context={}, limit=100)
+        rpc_execute(:name_search, name, to_openerp_domain(domain), operator, context, limit)
+      end
+
+      def rpc_execute(method, *args)
+        object_service(:execute, openerp_model, method, *args)
+      end
+
+      def rpc_exec_workflow(action, *args)
+        object_service(:exec_workflow, openerp_model, action, *args)
+      end
+
+      def object_service(service, obj, method, *args)
+        reload_fields_definition(false, connection.connection_session)
+        cast_answer_to_ruby!(connection.object.object_service(service, obj, method, *cast_request_to_openerp(args)))
+      end
+
+      def method_missing(method_symbol, *args)
+        raise RuntimeError.new("Invalid RPC method:  #{method_symbol}") if [:type!, :allowed!].index(method_symbol)
+        self.rpc_execute(method_symbol.to_s, *args)
+      end
+
+      # ******************** AREL Minimal implementation ***********************
+
+      def relation(context={}); @relation ||= Relation.new(self, context); end #TODO template
+      def scoped(context={}); relation(context); end
+      def where(opts, *rest); relation.where(opts, *rest); end
+      def all(*args); relation.all(*args); end
+      def limit(value); relation.limit(value); end
+      def order(value); relation.order(value); end
+      def offset(value); relation.offset(value); end
+      
+      def logger; Ooor.logger; end
+
+    end
+
+    self.name = "Base"
+
+    # ********************** instance methods **********************************
+
+    attr_accessor :associations, :loaded_associations, :ir_model_data_id, :object_session
+
+    def rpc_execute(method, *args)
+      args += [self.class.connection.connection_session.merge(object_session)] unless args[-1].is_a? Hash
+      self.class.object_service(:execute, self.class.openerp_model, method, *args)
+    end
+
+    def load(attributes, remove_root=false, persisted=false)#an attribute might actually be a association too, will be determined here
+      self.class.reload_fields_definition(false, object_session)
+      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+      @prefix_options, attributes = split_options(attributes)
+      @associations ||= {}
+      @attributes ||= {}
+      @loaded_associations = {}
+      attributes.each do |key, value|
+        skey = key.to_s
+        if self.class.associations_keys.index(skey) || value.is_a?(Array) #FIXME may miss m2o with inherits!
+          @associations[skey] = value #the association because we want the method to load the association through method missing
+        else
+          @attributes[skey] = value || nil #don't bloat with false values
+        end
+      end
+      self
+    end
+
+    #takes care of reading OpenERP default field values.
+    def initialize(attributes = {}, default_get_list=false, context={}, persisted=false)
+      @attributes = {}
+      @prefix_options = {}
+      @ir_model_data_id = attributes.delete(:ir_model_data_id)
+      @object_session = {}
+      @object_session = HashWithIndifferentAccess.new(context)
+      @persisted = persisted
+      self.class.reload_fields_definition(false, @object_session)
+      if default_get_list == []
+        load(attributes)
+      else
+        load_with_defaults(attributes, default_get_list)
+      end
+    end
+
+    def save(context={}, reload=true)
+      new? ? create(context, reload) : update(context, reload)
+    rescue ValidationError => e
+      e.extract_validation_error!(errors)
+      return false
+    end
+
+    #compatible with the Rails way but also supports OpenERP context
+    def create(context={}, reload=true)
+      self.id = rpc_execute('create', to_openerp_hash, context)
+      if @ir_model_data_id
+        IrModelData.create(model: self.class.openerp_model,
+          'module' => @ir_model_data_id[0],
+          'name' => @ir_model_data_id[1],
+          'res_id' => self.id)
+      end
+      reload_from_record!(self.class.find(self.id, context: context)) if reload
+      @persisted = true
+    end
+
+    def update_attributes(attributes, context={}, reload=true)
+      load(attributes, false) && save(context, reload)
+    end
+
+    #compatible with the Rails way but also supports OpenERP context
+    def update(context={}, reload=true) #TODO use http://apidock.com/rails/ActiveRecord/Dirty to minimize data to save back
+      rpc_execute('write', [self.id], to_openerp_hash, context)
+      reload_fields(context) if reload
+      @persisted = true
+    end
+
+    #compatible with the Rails way but also supports OpenERP context
+    def destroy(context={})
+      rpc_execute('unlink', [self.id], context)
+    end
+
+    #OpenERP copy method, load persisted copied Object
+    def copy(defaults={}, context={})
+      self.class.find(rpc_execute('copy', self.id, defaults, context), context: context)
+    end
+
+    #Generic OpenERP rpc method call
+    def call(method, *args) rpc_execute(method, *args) end
+
+    #Generic OpenERP on_change method
+    def on_change(on_change_method, field_name, field_value, *args)
+      # NOTE: OpenERP doesn't accept context systematically in on_change events unfortunately
+      ids = self.id ? [id] : []
+      result = self.class.object_service(:execute, self.class.openerp_model, on_change_method, ids, *args)
+      load_on_change_result(result, field_name, field_value)
+    end
+
+    #wrapper for OpenERP exec_workflow Business Process Management engine
+    def wkf_action(action, context={}, reload=true)
+      self.class.object_service(:exec_workflow, self.class.openerp_model, action, self.id, object_session)
+      reload_fields(context) if reload
+    end
+
+    #Add get_report_data to obtain [report["result"],report["format]] of a concrete openERP Object
+    def get_report_data(report_name, report_type="pdf", context={})
+      self.class.get_report_data(report_name, [self.id], report_type, context)
+    end
+
+    def type() method_missing(:type) end #skips deprecated Object#type method
+
+    private
+
+    def load_with_defaults(attributes, default_get_list)
+      defaults = rpc_execute("default_get", default_get_list || self.class.fields.keys + self.class.associations_keys, object_session.dup)
+      attributes = HashWithIndifferentAccess.new(defaults.merge(attributes.reject {|k, v| v.blank? }))
+      load(attributes)
+    end
+      
+    def load_on_change_result(result, field_name, field_value)
+      if result["warning"]
+        self.class.logger.info result["warning"]["title"]
+        self.class.logger.info result["warning"]["message"]
+      end
+      attrs = @attributes.merge(field_name => field_value)
+      attrs.merge!(result["value"])
+      load(attrs)
+    end
+
+    # Ruby 1.9.compat, See also http://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary/
+    def to_ary; nil; end # :nodoc:
+
+    def reload_from_record!(record) load(record.attributes.merge(record.associations)) end
+
+    def reload_fields(context)
+      records = self.class.find(self.id, context: context, fields: @attributes.keys + @associations.keys)
+      reload_from_record!(records)
+    end
+
+  end
+end

data/lib/ooor/connection.rb

@@ -0,0 +1,37 @@
+#    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
+
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Ooor
+  class Connection
+    attr_accessor :config, :connection_session
+
+    def initialize(config, env=false)
+      @config = _config(config)
+      Object.const_set(@config[:scope_prefix], Module.new) if @config[:scope_prefix]
+    end
+
+    def connection_session
+      @connection_session ||= {}.merge!(@config[:connection_session] || {})
+    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
+
+    private
+
+    def _config(config)
+      c = config.is_a?(String) ? Ooor.load_config(config, env) : config
+      HashWithIndifferentAccess.new(c)
+    end
+
+  end
+end

data/lib/ooor/errors.rb

@@ -0,0 +1,120 @@
+module Ooor
+  class OpenERPServerError < RuntimeError
+    attr_accessor :request, :faultCode, :faultString
+
+    def self.create_from_trace(error, method, *args)
+      begin
+        #extracts the eventual error log from OpenERP response as OpenERP doesn't enforce carefully*
+        #the XML/RPC spec, see https://bugs.launchpad.net/openerp/+bug/257581
+        openerp_error_hash = eval("#{error}".gsub("wrong fault-structure: ", ""))
+      rescue SyntaxError
+      end
+      if openerp_error_hash.is_a? Hash
+        build(openerp_error_hash['faultCode'], openerp_error_hash['faultString'], method, *args)
+      else
+        return UnknownOpenERPServerError.new("method: #{method} - args: #{args.inspect}")
+      end
+    end
+      
+    def self.build(faultCode, faultString, method, *args)
+      if faultCode =~ /AttributeError: /
+        return UnknownAttributeOrAssociationError.new("method: #{method} - args: #{args.inspect}", faultCode, faultString)
+      elsif faultCode =~ /TypeError: /
+        return TypeError.new(method, faultCode, faultString, *args)
+      elsif faultCode =~ /ValueError: /
+        return ValueError.new(method, faultCode, faultString, *args)
+      elsif faultCode =~ /ValidateError/
+        return ValidationError.new(method, faultCode, faultString, *args)
+      elsif faultCode =~ /AccessDenied/
+        return UnAuthorizedError.new(method, faultCode, faultString, *args)
+      elsif faultCode =~ /AuthenticationError: Credentials not provided/
+        return InvalidSessionError.new(method, faultCode, faultString, *args)
+      elsif faultCode =~ /SessionExpiredException/
+        return SessionExpiredError.new(method, faultCode, faultString, *args)
+      else
+        return new(method, faultCode, faultString, *args)
+      end
+    end
+
+    def initialize(method=nil, faultCode=nil, faultString=nil, *args)
+      filtered_args = filter_password(args.dup())
+      @request = "method: #{method} - args: #{filtered_args.inspect}"
+      @faultCode = faultCode
+      @faultString = faultString
+      super()
+    end
+    
+    def filter_password(args)
+      if args[0].is_a?(String) && (args[1].is_a?(Integer) || args[1].to_i != 0) && args[2].is_a?(String)
+        args[2] = "####"
+      end
+      args.map! do |arg|
+        if arg.is_a?(Hash)# && (arg.keys.index('password') || arg.keys.index(:password))
+          r = {}
+          arg.each do |k, v|
+            if k.to_s.index('password')
+              r[k] = "####"
+            else
+              r[k] = v
+            end
+          end
+          r
+        else
+          arg
+        end
+      end
+    end
+
+    def to_s()
+      s = super
+      line = "********************************************"
+      s = "\n\n#{line}\n***********     OOOR Request     ***********\n#{@request}\n#{line}\n\n"
+      s << "\n#{line}\n*********** OpenERP Server ERROR ***********\n#{line}\n#{@faultCode}\n#{@faultString}\n#{line}\n."
+      s
+    end
+
+  end
+
+
+  class UnknownOpenERPServerError < OpenERPServerError; end
+  class UnAuthorizedError < OpenERPServerError; end
+  class TypeError < OpenERPServerError; end
+  class ValueError < OpenERPServerError; end
+  class InvalidSessionError < OpenERPServerError; end
+  class SessionExpiredError < OpenERPServerError; end
+
+  class ValidationError < OpenERPServerError
+    def extract_validation_error!(errors)
+      @faultCode.split("\n").each do |line|
+        extract_error_line!(errors, line) if line.index(': ')
+      end
+    end
+
+    def extract_error_line!(errors, line)
+      fields = line.split(": ")[0].split(' ').last.split(',')
+      msg = line.split(": ")[1]
+      fields.each { |field| errors.add(field.strip.to_sym, msg) }
+    end
+  end
+  
+  class UnknownAttributeOrAssociationError < OpenERPServerError
+    attr_accessor :klass
+    
+    def to_s()
+      s = super
+      s << available_fields(@klass) if @klass
+      s
+    end
+
+    def available_fields(clazz)
+      msg = "\n\n*** AVAILABLE FIELDS ON #{clazz.name} ARE: ***"
+      msg << "\n\n" << clazz.t.fields.sort {|a,b| a[1]['type']<=>b[1]['type']}.map {|i| "#{i[1]['type']} --- #{i[0]}"}.join("\n")
+      %w[many2one one2many many2many polymorphic_m2o].each do |kind|
+        msg << "\n\n"
+        msg << (clazz.send "#{kind}_associations").map {|k, v| "#{kind} --- #{v['relation']} --- #{k}"}.join("\n")
+      end
+      msg
+    end
+  end
+
+end

data/lib/ooor/field_methods.rb

@@ -0,0 +1,153 @@
+require 'active_support/concern'
+
+module Ooor
+  module FieldMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def reload_fields_definition(force=false, context=connection.web_session)
+        if force || !fields
+          @t.fields = {}
+          @columns_hash = {}
+          fields_get = rpc_execute("fields_get", false, context)
+          fields_get.each { |k, field| reload_field_definition(k, field) }
+          @t.associations_keys = many2one_associations.keys + one2many_associations.keys + many2many_associations.keys + polymorphic_m2o_associations.keys
+          (fields.keys + associations_keys).each do |meth| #generates method handlers for auto-completion tools
+            define_field_method(meth)
+          end
+          one2many_associations.keys.each do |meth|
+            define_nested_attributes_method(meth)
+          end
+          logger.debug "#{fields.size} fields loaded in model #{self.name}"
+          Ooor.model_registry.set_template(connection.config, @t)
+        end
+      end
+
+      def all_fields
+        fields.merge(polymorphic_m2o_associations).merge(many2many_associations).merge(one2many_associations).merge(many2one_associations)
+      end
+
+      def fast_fields(options)
+        fields = all_fields
+        fields.keys.select do |k|
+          fields[k]["type"] != "binary" && (options[:include_functions] || !fields[k]["function"])
+        end
+      end
+      
+      # this is used by fields_for in ActionView FormHelper
+      def define_nested_attributes_method(meth)
+        p "define_nested_attributes_method", meth
+        unless self.respond_to?(meth)
+          self.instance_eval do
+            define_method "#{meth}_attributes=" do |*args|
+              self.send :method_missing, *[meth, *args]
+            end
+            define_method "#{meth}_attributes" do |*args|
+              self.send :method_missing, *[meth, *args]
+            end
+          end
+        end
+      end
+
+      private
+
+        def define_field_method(meth)
+          unless self.respond_to?(meth)
+            self.instance_eval do
+              define_method meth do |*args|
+                self.send :method_missing, *[meth, *args]
+              end
+            end
+          end
+        end
+
+        def reload_field_definition(k, field)
+          case field['type']
+          when 'many2one'
+            many2one_associations[k] = field
+          when 'one2many'
+            one2many_associations[k] = field
+          when 'many2many'
+            many2many_associations[k] = field
+          when 'reference'
+            polymorphic_m2o_associations[k] = field
+          else
+            fields[k] = field if field['name'] != 'id'
+          end
+        end
+    end
+
+    def method_missing(method_symbol, *arguments)
+      method_name = method_symbol.to_s
+      method_key = method_name.sub('=', '')
+      self.class.reload_fields_definition(false, object_session)
+      if attributes.has_key?(method_key)
+        if method_name.end_with?('=')
+          attributes[method_key] = arguments[0]
+        else
+          attributes[method_key]
+        end
+      elsif @loaded_associations.has_key?(method_name)
+        @loaded_associations[method_name]
+      elsif @associations.has_key?(method_name)
+        result = relationnal_result(method_name, *arguments)
+        @loaded_associations[method_name] = result and return result if result
+      elsif method_name.end_with?('=')
+        return method_missing_value_assign(method_key, arguments)
+      elsif self.class.fields.has_key?(method_name) || self.class.associations_keys.index(method_name) #unloaded field/association
+        return lazzy_load_field(method_name, *arguments)
+      # check if that is not a Rails style association with an _id[s][=] suffix:
+      elsif method_name.match(/_id$/) && self.class.associations_keys.index(rel=method_name.gsub(/_id$/, ""))
+        return many2one_id_method(rel, *arguments)
+      elsif method_name.match(/_ids$/) && self.class.associations_keys.index(rel=method_name.gsub(/_ids$/, ""))
+        return x_to_many_ids_method(rel, *arguments)
+      elsif id
+        rpc_execute(method_key, [id], *arguments) #we assume that's an action
+      else
+        super
+      end
+
+    rescue UnknownAttributeOrAssociationError => e
+      e.klass = self.class
+      raise e
+    end
+
+    private
+
+      def method_missing_value_assign(method_key, arguments)
+        if is_association_assignment(method_key)
+          @associations[method_key] = arguments[0]
+          @loaded_associations[method_key] = arguments[0]
+        elsif is_attribute_assignment(method_key)
+          @attributes[method_key] = arguments[0]
+        end
+      end
+
+      def is_association_assignment(method_key)
+        (self.class.associations_keys + self.class.many2one_associations.collect do |k, field|
+          klass = self.class.const_get(field['relation'])
+          klass.reload_fields_definition(false, object_session)
+          klass.t.associations_keys
+        end.flatten).index(method_key)
+      end
+
+      def is_attribute_assignment(method_key)
+        (self.class.fields.keys + self.class.many2one_associations.collect do |k, field|
+          klass = self.class.const_get(field['relation'])
+          klass.reload_fields_definition(false, object_session)
+          klass.t.fields.keys
+        end.flatten).index(method_key)
+      end
+
+      def lazzy_load_field(field_name, *arguments)
+        if attributes["id"]
+          load(rpc_execute('read', [id], [field_name], *arguments || object_session)[0] || {})
+          method_missing(field_name, *arguments)
+        else
+          nil
+        end
+      end
+
+  end
+end