ext_ooor 2.3.0.1

data/lib/ooor/helpers/core_helpers.rb

@@ -0,0 +1,83 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2009-2012 Akretion LTDA (<http://www.akretion.com>).
+#    Author: Akretion: Raphaël Valyi: CampToCamp: Nicolas Bessi, Joel Grand-Guillaume
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+Ooor.xtend('ir.module.module') do
+
+  ##########################################################################
+  # Get recursively the whole list of modules dependencies
+  # for a list of modules.
+  # Do not add the module if it already exists in the input list
+  # Input :
+  #  - modules : A [] of valid IrModuleModule instances with dependencies_id attribute
+  # Return
+  #  -  [] of dependencies
+  # Usage Example:
+  # dependency_modules = get_dependencies(modules)
+  def self.get_dependencies(modules)
+    dependency_modules = []
+    modules.select { |m| m.dependencies_id }.each do |mod|
+      mod.dependencies_id.each do |dep|
+        dep_module = self.find(:first,
+                               :domain => [['name', '=', dep.name]],
+                               :fields => ['id', 'state', 'dependencies_id'])
+        if dep_module.nil?
+          raise RuntimeError, "#{dep.name} not found"
+        end
+        dependency_modules << dep_module unless (modules + dependency_modules).map { |m| m.id }.include? dep_module.id
+      end
+    end
+    dependency_modules.concat(get_dependencies(dependency_modules)) if dependency_modules.count > 0
+    dependency_modules.uniq { |m| m.id }
+  end
+  
+  def self.install_modules(modules)
+    modules = modules.map { |name| self.find(:first, domain: {name: name})}
+    modules.each do |mod|
+      mod.button_install unless mod.state == "installed"
+    end
+    wizard = BaseModuleUpgrade.create
+    wizard.upgrade_module
+  end
+
+  def print_dependency_graph
+    modules = [self] + self.class.get_dependencies([self])
+
+    File.open("#{self.name}-pre.dot", 'w') do |f|
+      f << <<-eos
+      digraph DependenciesByOOOR {
+          fontname = "Helvetica"
+          fontsize = 11
+          label = "*** generated by OOOR by www.akretion.com ***"
+          node [
+                  fontname = "Helvetica"
+                  fontsize = 11
+                  shape = "record"
+                  fillcolor=orange
+                  style="rounded,filled"
+          ]
+      eos
+
+      modules.each do |m|
+        m.dependencies_id.each do |dep|
+          f << "#{m.name} -> #{dep.name};\n"
+        end
+      end
+      f << "}"
+    end
+    system("tred < #{self.name}-pre.dot > #{self.name}.dot")
+    cmd_line2 = "dot -Tcmapx -o#{self.name}.map -Tpng -o#{self.name}.png #{self.name}.dot"
+    system(cmd_line2)
+  end
+    
+end
+
+
+Ooor.xtend('ir.ui.menu') do
+  def menu_action
+    #TODO put in cache eventually:
+    action_values = self.class.ooor.const_get('ir.values').rpc_execute('get', 'action', 'tree_but_open', [['ir.ui.menu', id]], false, self.class.ooor.web_session)[0][2]#get already exists
+    @menu_action = self.class.ooor.const_get('ir.actions.act_window').new(action_values, []) #TODO deal with action reference instead
+  end
+end

data/lib/ooor/locale.rb

@@ -0,0 +1,11 @@
+module Ooor
+  module Locale
+    # Odoo requires a locale+zone mapping while Rails uses locale only, so mapping is likely to be required
+    def self.to_erp_locale(locale)
+      unless mapping = Ooor.default_config[:locale_mapping]
+        mapping = {'fr' => 'fr_FR', 'en' => 'en_US'}
+      end
+      (mapping[locale.to_s] || locale.to_s).gsub('-', '_')
+    end
+  end
+end

data/lib/ooor/mini_active_resource.rb

@@ -0,0 +1,86 @@
+require 'active_support'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_model'
+
+if ActiveModel.respond_to?(:version) && ActiveModel.version.version.to_i >= 5
+  begin
+    require 'active_model_serializers'
+    require 'activemodel-serializers-xml'
+  rescue LoadError
+    puts """When using ActiveModel or Rails 5+, you should add
+    gem 'active_model_serializers'
+    gem 'activemodel-serializers-xml'
+    in your Gemfile.
+    """
+  end
+end
+
+
+module Ooor
+  # Ooor::MiniActiveResource is a shrinked version of ActiveResource::Base with the bare minimum we need for Ooor.
+  # as a reminder ActiveResource::Base is the main class for mapping RESTful resources as models in a Rails application.
+  # Ooor is a bit like ActiveResource but eventually it can use more OpenERP metadata and a richer API
+  # to become closer to ActiveRecord or Mongoid than Activeresource. Also OpenERP isn't really good at REST
+  # so the part of ActiveResource dedicated to REST is of little help here.
+  # An other fundamental difference is Ooor is multi OpenERP instances and multi-sessions.
+  # for each session, proxies to OpenERP may be different.
+  class MiniActiveResource
+
+    class << self
+      def element_name
+        @element_name ||= model_name.element
+      end
+    end
+
+    attr_accessor :attributes, :id
+
+    def to_json(options={})
+      raise "you should add gem 'active_model_serializers' in your Gemfile" unless defined?(ActiveModel::Serializers::JSON)
+      super(include_root_in_json ? { :root => self.class.element_name }.merge(options) : options)
+    end
+
+    def to_xml(options={})
+      raise "you should add gem 'activemodel-serializers-xml' in your Gemfile" unless defined?(ActiveModel::Serializers::Xml)
+      super({ :root => self.class.element_name }.merge(options))
+    end
+
+    # Returns +true+ if this object hasn't yet been saved, otherwise, returns +false+.
+    def new?
+      !@persisted
+    end
+    alias :new_record? :new?
+
+    def persisted?
+      @persisted
+    end
+
+    def id
+      attributes["id"]
+    end
+
+    # Sets the <tt>\id</tt> attribute of the resource.
+    def id=(id)
+      attributes["id"] = id.to_i # NOTE added to_i for Ooor (HTML forms can pass it as a string)
+    end
+
+    # Reloads the record from the database.
+    #
+    # This method finds record by its primary key (which could be assigned manually) and
+    # modifies the receiver in-place
+    # NOTE in Ooor, like ActiveRecord and unlike ActiveResource, reload can take an options parameter
+    def reload(options = nil)
+      self.class.find(id, options)
+    end
+
+    # Returns the Errors object that holds all information about attribute error messages.
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+
+
+    include ActiveModel::Conversion
+    include ActiveModel::Serializers::JSON if defined?(ActiveModel::Serializers::JSON)
+    include ActiveModel::Serializers::Xml if defined?(ActiveModel::Serializers::Xml)
+
+  end
+end

data/lib/ooor/model_registry.rb

@@ -0,0 +1,24 @@
+module Ooor
+  # Enables to cache expensive model metadata and reuse these metadata
+  # according to connection parameters. Indeed, these metadata are
+  # expensive before they require a fields_get request to OpenERP
+  # so in a web application with several worker processes, it's a good
+  # idea to cache them and share them using a data store like Memcache
+  class ModelRegistry
+    
+    def cache_key(config, model_name)
+      h = {url: config[:url], database: config[:database], username: config[:username], scope_prefix: config[:scope_prefix]}
+      (h.map{|k, v| v} + [model_name]).join('-')
+    end
+
+    def get_template(config, model_name)
+      Ooor.cache.read(cache_key(config, model_name))
+    end
+    
+    def set_template(config, model)
+      key = cache_key(config, model.openerp_model)
+      Ooor.cache.write(key, model)
+    end
+
+  end
+end

data/lib/ooor/model_schema.rb

@@ -0,0 +1,25 @@
+#    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
+
+  # Meta data shared across sessions, a cache of the data in ir_model in OpenERP.
+  # in Activerecord, ModelSchema is a module and its properties are carried by the
+  # ActiveRecord object. But in Ooor we don't want do do that because the Ooor::Base
+  # object is different for each session, so instead we delegate the schema
+  # properties to some ModelSchema instance that is shared between sessions, 
+  # reused accross workers in a multi-process web app (via memcache for instance).
+  class ModelSchema
+
+    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]
+
+      attr_accessor *TEMPLATE_PROPERTIES, :name, :columns_hash
+  end
+
+end

data/lib/ooor/naming.rb

@@ -0,0 +1,92 @@
+require 'active_support/concern'
+
+module Ooor
+  module Naming
+    extend ActiveSupport::Concern
+
+    class Name < ActiveModel::Name
+      def initialize(klass, namespace = nil, name = nil)
+        super
+        @singular = klass.openerp_model
+        @plural = klass.openerp_model # OpenERP doesn't enforce plural / singular conventions sadly...
+        @element = klass.openerp_model
+        @human = klass.description || klass.openerp_model
+        @param_key = klass.openerp_model.gsub('.', '_')
+        @i18n_key = klass.openerp_model
+        @route_key = klass.openerp_model.gsub('.', '-')
+        @singular_route_key = klass.openerp_model.gsub('.', '-')
+      end
+    end
+
+    module ClassMethods
+      def model_name
+        @_model_name ||= begin
+          if self.respond_to?(:openerp_model) && self.t
+            namespace = self.parents.detect do |n|
+              n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+            end
+            Ooor::Naming::Name.new(self, namespace)
+          else
+            super
+          end
+        end
+      end
+
+      def param_key(context={})
+        self.alias(context).gsub('.', '-') # we don't use model_name because model_name isn't bijective
+      end
+
+      #similar to Object#const_get but for OpenERP model key
+      def const_get(model_key)
+        scope = self.scope_prefix ? Object.const_get(self.scope_prefix) : Object
+        klass_name = session.class_name_from_model_key(model_key)
+        if scope.const_defined?(klass_name) && Ooor.session_handler.noweb_session_spec(scope.const_get(klass_name).session.config) == Ooor.session_handler.noweb_session_spec(session.config)
+          scope.const_get(klass_name)
+        else
+          session.define_openerp_model(model: model_key, scope_prefix: self.scope_prefix)
+        end
+      end
+
+      #required by form validators; TODO implement better?
+      def human_attribute_name(field_name, options={})
+        ""
+      end
+
+      def param_field
+        session.config[:param_keys] && session.config[:param_keys][openerp_model] || :id
+      end
+
+      def find_by_permalink(param, options={})
+        # NOTE in v8, see if we can use PageConverter here https://github.com/akretion/openerp-addons/blob/trunk-website-al/website/models/ir_http.py#L138
+        if param.split('-').last.to_i != 0
+          options.merge!(domain: {:id => param.split('-').last.to_i})
+        elsif param.to_i == 0
+          options.merge!(domain: [param_field, 'ilike', param])
+        else
+          options.merge!(domain: {:id => param.to_i})
+        end
+        find(:first, options)
+      end
+
+      def alias(context={})
+        # NOTE in v8, see if we can use ModelConvert here https://github.com/akretion/openerp-addons/blob/trunk-website-al/website/models/ir_http.py#L126
+        if session.config[:aliases]
+          lang = context['lang'] || session.config['lang'] || 'en_US'
+          if alias_data = session.config[:aliases][lang]
+            alias_data.select{|key, value| value == openerp_model }.keys[0] || openerp_model
+          else
+            openerp_model
+          end
+        else
+          openerp_model
+        end
+      end
+    end
+
+    def to_param
+      field = self.class.param_field
+      send(field) && send(field).to_s
+    end
+
+  end
+end

data/lib/ooor/nested_attributes.rb

@@ -0,0 +1,57 @@
+require 'ostruct'
+require 'active_support/concern'
+
+module Ooor
+  module NestedAttributes #:nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Defines an attributes writer for the specified association(s).
+      # Note that in Ooor this is active by default for all one2many and many2one associations
+      def accepts_nested_attributes_for(*attr_names)
+        attr_names.each do |association_name|
+          if rel = all_fields[association_name]
+            reflection = OpenStruct.new(rel.merge({options: {autosave: true}, name: association_name})) #TODO use a reflection class
+            generate_association_writer(association_name, :collection) #TODO add support for m2o
+            add_autosave_association_callbacks(reflection)
+          else
+            raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
+          end
+        end
+      end
+
+      private
+
+      # Generates a writer method for this association. Serves as a point for
+      # accessing the objects in the association. For example, this method
+      # could generate the following:
+      #
+      #   def pirate_attributes=(attributes)
+      #     assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
+      #   end
+      #
+      # This redirects the attempts to write objects in an association through
+      # the helper methods defined below. Makes it seem like the nested
+      # associations are just regular associations.
+      def generate_association_writer(association_name, type)
+        unless self.respond_to?(association_name)
+          self.instance_eval do
+            define_method "#{association_name}_attributes=" do |*args|
+              send("#{association_name}_will_change!")
+#              @associations[association_name] = args[0] # TODO what do we do here?
+              association_obj = self.class.reflect_on_association(association_name).klass
+              associations = []
+              (args[0] || {}).each do |k, v|
+                persisted = !v['id'].blank? || v[:id]
+                associations << association_obj.new(v, [], persisted, true) #TODO eventually use k to set sequence
+              end
+              @loaded_associations[association_name] = associations
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ooor/persistence.rb

@@ -0,0 +1,353 @@
+#    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/hash/indifferent_access'
+require 'active_model/attribute_methods'
+require 'active_model/dirty'
+require 'ooor/errors'
+
+module Ooor
+  # = Ooor RecordInvalid
+  #
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid. Use the
+  # +record+ method to retrieve the record which did not validate.
+  #
+  #   begin
+  #     complex_operation_that_calls_save!_internally
+  #   rescue ActiveRecord::RecordInvalid => invalid
+  #     puts invalid.record.errors
+  #   end
+  class RecordInvalid < OpenERPServerError
+    attr_reader :record # :nodoc:
+    def initialize(record) # :nodoc:
+      @record = record
+      errors = @record.errors.full_messages.join(", ")
+      super(I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", :errors => errors, :default => :"errors.messages.record_invalid"))
+    end
+  end
+
+  # = Ooor Persistence
+  # Note that at the moment it also includes the Validations stuff as it is quite superficial in Ooor
+  # Most of the time, when we talk about validation here we talk about extra Rails validations
+  # as OpenERP validations will happen anyhow when persisting records to OpenERP.
+  # some of the methods found in ActiveRecord Persistence which are identical in ActiveResource
+  # may be found in the Ooor::MiniActiveResource module instead
+  module Persistence
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    module ClassMethods
+
+      # Creates an object (or multiple objects) and saves it to the database, if validations pass.
+      # The resulting object is returned whether the object was saved successfully to the database or not.
+      #
+      # The +attributes+ parameter can be either a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be created.
+      # 
+      # the +default_get_list+ parameter differs from the ActiveRecord API
+      # it is used to tell OpenERP the list of fields for which we want the default values
+      # false will request all default values while [] will not ask for any default value (faster)
+      # +reload+ can be set to false to indicate you don't want to reload the record after it is saved
+      # which will save a roundtrip to OpenERP and perform faster.
+      def create(attributes = {}, default_get_list = false, reload = true, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, &block) }
+        else
+          object = new(attributes, default_get_list, &block)
+          object.save(reload)
+          object
+        end
+      end
+
+      # Creates an object just like Base.create but calls <tt>save!</tt> instead of +save+
+      # so an exception is raised if the record is invalid.
+      def create!(attributes = {}, default_get_list = false, reload = true, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr, &block) }
+        else
+          object = new(attributes, default_get_list)
+          yield(object) if block_given?
+          object.save!(reload)
+          object
+        end
+      end
+
+    end
+
+    # Returns true if this object has been destroyed, otherwise returns false.
+    def destroyed?
+      @destroyed
+    end
+
+    # Flushes the current object and loads the +attributes+ Hash
+    # containing the attributes and the associations into the current object
+    def load(attributes)
+      self.class.reload_fields_definition(false)
+      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+      @associations ||= {}
+      @attributes ||= {}
+      @loaded_associations = {}
+      attributes.each do |key, value|
+        self.send "#{key}=", value if self.respond_to?("#{key}=")
+      end
+      self
+    end
+
+    #takes care of reading OpenERP default field values.
+    def initialize(attributes = {}, default_get_list = false, persisted = false, has_changed = false, lazy = false)
+      self.class.reload_fields_definition(false)
+      @attributes = {}
+      @ir_model_data_id = attributes.delete(:ir_model_data_id)
+      @marked_for_destruction = false
+      @persisted = persisted
+      @lazy = lazy
+      if default_get_list == []
+        load(attributes)
+      else
+        load_with_defaults(attributes, default_get_list)
+      end.tap do
+        if id && !has_changed
+          @previously_changed = ActiveSupport::HashWithIndifferentAccess.new # see ActiveModel::Dirty reset_changes
+          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+        end
+      end
+    end
+
+    # Saves the model.
+    #
+    # If the model is new a record gets created in OpenERP, otherwise
+    # the existing record gets updated.
+    #
+    # By default, save always run validations. If any of them fail the action
+    # is cancelled and +save+ returns +false+. However, if you supply
+    # validate: false, validations are bypassed altogether.
+    # In Ooor however, real validations always happen on the OpenERP side
+    # so the only validations you can bypass or not are extra pre-validations
+    # in Ruby if you have any.
+    #
+    # There's a series of callbacks associated with +save+. If any of the
+    # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
+    # +save+ returns +false+. See ActiveRecord::Callbacks for further
+    # details.
+    #
+    # Attributes marked as readonly are silently ignored if the record is
+    # being updated. (TODO)
+    def save(options = {})
+      perform_validations(options) ? save_without_raising(options) : false
+    end
+
+    # Attempts to save the record just like save but will raise a +RecordInvalid+
+    # exception instead of returning +false+ if the record is not valid.
+    def save!(options = {})
+      perform_validations(options) ? save_without_raising(options) : raise(RecordInvalid.new(self))
+    end
+
+    # Deletes the record in OpenERP and freezes this instance to
+    # reflect that no changes should be made (since they can't be
+    # persisted). Returns the frozen instance.
+    #
+    # no callbacks are executed.
+    #
+    # To enforce the object's +before_destroy+ and +after_destroy+
+    # callbacks or any <tt>:dependent</tt> association
+    # options, use <tt>#destroy</tt>.
+    def delete
+      rpc_execute('unlink', [id], context) if persisted?
+      @destroyed = true
+      freeze
+    end
+
+    # Deletes the record in OpenERP and freezes this instance to reflect
+    # that no changes should be made (since they can't be persisted).
+    #
+    # There's a series of callbacks associated with <tt>destroy</tt>. If
+    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
+    # and <tt>destroy</tt> returns +false+. See
+    # ActiveRecord::Callbacks for further details.
+    def destroy
+      run_callbacks :destroy do
+        rpc_execute('unlink', [id], context)
+        @destroyed = true
+        freeze 
+      end
+    end
+
+    # Deletes the record in the database and freezes this instance to reflect
+    # that no changes should be made (since they can't be persisted).
+    #
+    # There's a series of callbacks associated with <tt>destroy!</tt>. If
+    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
+    # and <tt>destroy!</tt> raises ActiveRecord::RecordNotDestroyed. See
+    # ActiveRecord::Callbacks for further details.
+    def destroy! #TODO
+      destroy || raise(ActiveRecord::RecordNotDestroyed)
+    end
+
+    #TODO implement becomes / becomes! eventually
+
+    # Updates a single attribute and saves the record.
+    # This is especially useful for boolean flags on existing records. Also note that
+    #
+    # * Validation is skipped.
+    # * Callbacks are invoked.
+    # * updated_at/updated_on column is updated if that column is available.
+    # * Updates all the attributes that are dirty in this object.
+    #
+    # This method raises an +ActiveRecord::ActiveRecordError+  if the
+    # attribute is marked as readonly.
+    #
+    # See also +update_column+.
+    def update_attribute(name, value)
+      send("#{name}=", value)
+      save(validate: false)
+    end
+
+    # Updates the attributes of the model from the passed-in hash and saves the
+    # record, all wrapped in a transaction. If the object is invalid, the saving
+    # will fail and false will be returned.
+    def update(attributes, reload=true)
+      load(attributes) && save(reload)
+    end
+
+    alias update_attributes update
+
+    # Updates its receiver just like +update+ but calls <tt>save!</tt> instead
+    # of +save+, so an exception is raised if the record is invalid.
+    def update!(attributes, reload=true)
+      load(attributes) && save!(reload)
+    end
+
+    alias update_attributes! update!
+
+    #OpenERP copy method, load persisted copied Object
+    def copy(defaults={}, context={})
+      self.class.find(rpc_execute('copy', id, defaults, context), context: context)
+    end
+
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, +false+ otherwise.
+    #
+    # Aliased as validate.
+    #
+    # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
+    end
+
+    alias_method :validate, :valid?
+
+  protected
+
+    # Real validations happens on OpenERP side, only pre-validations can happen here eventually
+    def perform_validations(options={}) # :nodoc:
+      if options.is_a?(Hash)
+        options[:validate] == false || valid?(options[:context])
+      else
+        valid?
+      end
+    end
+
+  private
+
+    def create_or_update(options={})
+      run_callbacks :save do
+        new? ? create_record(options) : update_record(options)
+      end
+    rescue ValidationError => e
+      e.extract_validation_error!(errors)
+      return false
+    end
+
+    def update_record(options)
+      run_callbacks :update do
+        rpc_execute('write', [self.id], to_openerp_hash, context)
+        reload_fields if should_reload?(options)
+        @persisted = true
+      end
+    end
+
+    def create_record(options={})
+      run_callbacks :create do
+        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
+        @persisted = true
+        reload_fields if should_reload?(options)
+      end
+    end
+
+    def save_without_raising(options = {})
+      create_or_update(options)
+    rescue Ooor::RecordInvalid
+      false
+    end
+
+    def should_validate?(options)
+      if options.is_a?(Hash)
+        options[:validate] != false
+      else
+        true
+      end
+    end
+
+    def should_reload?(options)
+      if options == false
+        false
+      elsif options.is_a?(Hash) && options[:reload] == false
+        false
+      else
+        true
+      end
+    end
+
+    def load_with_defaults(attributes, default_get_list)
+      defaults = rpc_execute("default_get", default_get_list || self.class.fields.keys + self.class.associations_keys, context)
+      self.class.associations_keys.each do |k|
+        # m2m with existing records:
+        if defaults[k].is_a?(Array) && defaults[k][0].is_a?(Array) && defaults[k][0][2].is_a?(Array)
+          defaults[k] = defaults[k][0][2]
+        # m2m with records to create:
+        elsif defaults[k].is_a?(Array) && defaults[k][0].is_a?(Array) && defaults[k][0][2].is_a?(Hash) # TODO make more robust
+          defaults[k] = defaults[k].map { |item| self.class.all_fields[k]['relation'].new(item[2]) }
+        # strange case with default product taxes on v9
+        elsif defaults[k].is_a?(Array) && defaults[k][0] == [5] && defaults[k][1].is_a?(Array)
+          defaults[k] = [defaults[k][1].last] # TODO may e more subtle
+        # default ResPartners category_id on v9; know why...
+        elsif defaults[k].is_a?(Array) && defaults[k][0].is_a?(Array)
+          defaults[k] = defaults[k][0]
+        end
+      end
+      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
+
+    def reload_fields
+      record = self.class.find(self.id, context: context)
+      load(record.attributes.merge(record.associations))
+      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new # see ActiveModel::Dirty
+    end
+
+  end
+end