ext_ooor 2.3.0.1

data/lib/ooor/base.rb

@@ -0,0 +1,130 @@
+#    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
+
+require 'active_support/core_ext/module/delegation.rb'
+require 'active_model/attribute_methods'
+require 'active_model/dirty'
+require 'ooor/reflection'
+require 'ooor/reflection_ooor'
+require 'ooor/errors'
+
+module Ooor
+
+  # the base class for proxies to OpenERP objects
+  class Base < Ooor::MiniActiveResource
+    include Naming, TypeCasting, Serialization, ReflectionOoor, Reflection
+    include Associations, Report, FinderMethods, FieldMethods, AutosaveAssociation, NestedAttributes
+
+    # ********************** class methods ************************************
+    class << self
+
+      attr_accessor :name, :session, :t, :scope_prefix
+      delegate *ModelSchema::TEMPLATE_PROPERTIES, to: :t
+
+      # ******************** remote communication *****************************
+
+      #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', limit=100, context={})
+        if session.odoo_serie < 10
+          rpc_execute(:name_search, name, to_openerp_domain(domain), operator, context, limit)
+        else
+          rpc_execute(:name_search, name, to_openerp_domain(domain), operator, limit)
+        end
+      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)
+        cast_answer_to_ruby!(session.object.object_service(service, obj, method, *cast_request_to_openerp(args)))
+      end
+
+      def context
+        session.session_context
+      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 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 first(*args); relation.first(*args); end
+      def last(*args); relation.last(*args); end
+      def includes(*args); relation.includes(*args); end
+
+
+      def logger; Ooor.logger; end
+
+      private
+
+      def relation; @relation ||= Relation.new(self); end
+
+    end
+
+    self.name = "Base"
+
+    # ********************** instance methods **********************************
+
+    attr_accessor :associations, :loaded_associations, :ir_model_data_id
+
+    include Persistence, Callbacks, ActiveModel::Dirty
+
+    def rpc_execute(method, *args)
+      args += [self.class.context] unless args[-1].is_a? Hash
+      self.class.object_service(:execute, self.class.openerp_model, method, *args)
+    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, context)
+      reload_fields 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 context
+      self.class.context
+    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:
+
+  end
+end

data/lib/ooor/base64.rb

@@ -0,0 +1,20 @@
+#    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
+
+autoload :Base64, 'base64'
+
+module Base64
+  def serialize_binary_from_file(binary_path)
+    return Base64.encode64(File.read(binary_path))
+  end
+
+  def serialize_binary_from_content(content)
+    return Base64.encode64(content)
+  end
+
+  def unserialize_binary(content)
+    return Base64.decode64(content)
+  end
+end

data/lib/ooor/callbacks.rb

@@ -0,0 +1,18 @@
+module Ooor
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :before_validation, :after_validation, :before_save, :around_save, :after_save,
+      :before_create, :around_create, :after_create, :before_update, :around_update,
+      :after_update, :before_destroy, :around_destroy, :after_destroy
+    ]
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :save, :create, :update, :destroy
+    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: / || faultCode =~ /object has no attribute/
+        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/ || faultCode =~ /Access Denied/ || faultCode =~ /AccessError/
+        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[2].is_a?(String) && (args[1].is_a?(Integer) || (args[1].respond_to?(:to_i) && args[1].to_i != 0))
+        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,213 @@
+require 'active_support/concern'
+
+module Ooor
+  module FieldMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def reload_fields_definition(force=false)
+        if force || !fields
+          @t.fields = {}
+          @columns_hash = {}
+          if session.odoo_serie < 10
+            fields_get = rpc_execute("fields_get", false, context)
+          else
+            fields_get = rpc_execute("fields_get", false)
+          end
+          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
+          logger.debug "#{fields.size} fields loaded in model #{self.name}"
+          Ooor.model_registry.set_template(session.config, @t)
+        end
+        generate_accessors if fields != {} && (force || !@accessor_defined) #TODOmove in define_accessors method
+      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
+
+      private
+
+      def generate_accessors #TODO we should cache this is a module cached like the template, or eventually generate source code or both
+        fields.keys.each { |meth| define_field_method meth }
+        associations_keys.each { |meth| define_association_method meth }
+        one2many_associations.keys.each { |meth| accepts_nested_attributes_for meth } #TODO do it for m2o too
+        many2one_associations.keys.each do |meth|
+          define_association_method meth
+          define_m2o_association_method meth
+        end
+        (one2many_associations.keys + many2many_associations.keys).each do |meth|
+          define_association_method meth
+          alias_method "#{meth}_ids=", "#{meth}="
+          alias_method "#{meth.to_s.singularize}_ids=", "#{meth}="
+          define_x2m_ids_association_method meth
+          alias_method "#{meth.to_s.singularize}_ids", "#{meth}_ids"
+        end
+        @accessor_defined = true
+      end
+
+      def define_field_method(meth)
+        define_attribute_method meth
+        define_method meth do |*args|
+          get_attribute(meth, *args)
+        end
+
+        define_method "#{meth}=" do |*args|
+          set_attribute(meth, *args)
+        end
+      end
+
+      def define_association_method(meth)
+        define_attribute_method meth
+        define_method meth do |*args|
+          get_association(meth, *args)
+        end
+
+        define_method "#{meth}=" do |*args|
+          set_association(meth, *args)
+        end
+      end
+
+      def define_x2m_ids_association_method(meth)
+        define_method "#{meth}_ids" do |*args|
+          @associations[meth]
+        end
+      end
+
+      def define_m2o_association_method(meth)
+        define_method "#{meth}_id" do |*args|
+          if @associations[meth].is_a? Array
+            @associations[meth][0]
+          else
+            r = get_association(meth, *args)
+            r.is_a?(Ooor::Base) ? r.id : r
+          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
+
+    attr_accessor :_display_name
+    alias _name _display_name
+
+    def _destroy=(dummy)
+      @marked_for_destruction = true unless dummy.blank? || ["false", "0", 0].index(dummy)
+    end
+
+    def _destroy
+      @marked_for_destruction
+    end
+
+    def lazy_load(meth, *args)
+      @lazy = false
+      fields = (self.class.fast_fields + [meth]).uniq
+      load(rpc_execute('read', [@attributes["id"]], fields, *args || context)[0]).tap do
+        @lazy = false
+      end
+    end
+
+    def get_attribute(meth, *args)
+      lazy_load(meth, *args) if @lazy && @attributes["id"] && !@attributes.has_key?(meth)
+      if @attributes.has_key?(meth)
+        @attributes[meth]
+      elsif @attributes["id"] # if field is computed for instance
+        @attributes[meth] = rpc_execute('read', [@attributes["id"]], [meth], *args || context)[0][meth]
+      else
+        nil
+      end
+    end
+
+    def set_attribute(meth, *args)
+      value = sanitize_attribute(meth, args[0])
+      @attributes[meth] ||= nil
+      send("#{meth}_will_change!") unless @attributes[meth] == value
+      @attributes[meth] = value
+    end
+
+    def get_association(meth, *args)
+      return @associations[meth] || :undef if @skip
+      lazy_load(meth, *args) if @lazy
+      if @loaded_associations.has_key?(meth)
+        @loaded_associations[meth]
+      elsif @associations.has_key?(meth)
+        @loaded_associations[meth] = relationnal_result(meth, *args)
+      else
+        if @attributes["id"]
+          @associations[meth] = rpc_execute('read', [@attributes["id"]], [meth], *args || context)[0][meth]
+          @loaded_associations[meth] = relationnal_result(meth, *args)
+        elsif self.class.one2many_associations.has_key?(meth) || self.class.many2many_associations.has_key?(meth)
+          load_x2m_association(meth, [], *args)
+        else
+          nil
+        end
+      end
+    end
+
+    def set_association(meth, *args)
+      value = sanitize_association(meth, args[0])
+      if self.class.many2one_associations.has_key?(meth) # TODO detect false positives changes for other associations too
+        if @associations[meth].is_a?(Array) && @associations[meth][0] == value \
+           || @associations[meth] == value #\
+          return value
+        end
+      end
+      @skip = true
+      send("#{meth}_will_change!")
+      @skip = false
+      if value.is_a?(Ooor::Base) || value.is_a?(Array) && !value.empty? && value.all? {|i| i.is_a?(Ooor::Base)}
+        @loaded_associations[meth] = value
+      else
+        @loaded_associations.delete(meth)
+      end
+      @associations[meth] = value
+    end
+
+#    # Raise NoMethodError if the named attribute does not exist in order to preserve behavior expected by #clone.
+#    def attribute(name)
+#      key = name.to_s
+#      if self.class.fields.has_key?(key) #TODO check not symbols
+#        get_attribute(key)
+#      elsif self.class.associations_keys.index(key)
+#        get_association(key)
+#      else
+#        raise NoMethodError
+#      end
+#    end
+
+    def method_missing(method_symbol, *arguments)
+      self.class.reload_fields_definition(false)
+      if id
+        rpc_execute(method_symbol, [id], *arguments) #we assume that's an action
+      else
+        super
+      end
+    rescue UnknownAttributeOrAssociationError => e
+      e.klass = self.class
+      raise e
+    end
+
+  end
+end