ooor 1.4.2 → 1.5.0

data/README.md

@@ -3,10 +3,10 @@ OOOR - OpenObject On Rails
 
 <table>
     <tr>
-        <td><a href="http://github.com/rvalyi/ooor" title="OOOR - OpenObject On Rails"><img src="http://sites.google.com/site/assetserversite/_/rsrc/1257126460164/home/ooor_s.jpg" width="159px" height="124px" /></a></td>
+        <td width="159px"><a href="http://github.com/rvalyi/ooor" title="OOOR - OpenObject On Rails"><img src="http://akretion.s3.amazonaws.com/assets/ooor_m.jpg" width="159px" height="124px" /></a></td>
         <td><b>BY</b></td>
-        <td><a href="http://www.akretion.com" title="Akretion - open source to spin the world"><img src="http://sites.google.com/a/akretion.com/assetserver/_/rsrc/1276813508598/home/logo.png?height=154&width=320" width="320px" height="154px" /></a></td>
-        <td>
+        <td width="320px"><a href="http://www.akretion.com" title="Akretion - open source to spin the world"><img src="http://akretion.s3.amazonaws.com/assets/logo.png" width="320px" height="154px" /></a></td>
+        <td width="285px">
 OOOR stands for OpenObject On Rails. OpenObject is the RAD framework behind OpenERP,
 the ERP that doesn't hurt, just like Rails is "web development that doesn't hurt".
 So OOOR exposes seamlessly your OpenOpbject application, to your custom Rails application.
@@ -85,6 +85,8 @@ Trying it simply
 If you have Java 1.6+ installed, then the easiest way to tryout OOOR might be to download the [TerminatOOOR zip](http://github.com/rvalyi/terminatooor/downloads)
 and double-click on jruby-ooor.jar or launch it by command line with java -jar jruby-ooor.jar: it will launch an OOOR console with helpful auto-completion (hit 'tab') on OpenERP business objects.
 
+You can read [an introduction to OOOR on Akretion's blog.](http://www.akretion.com/en/blog/2010/01/18/introducing-ooor---openobject-on-rails-drivingrequesting-your-openerp-became-a-child-play/)
+
 
 
 Installation
@@ -105,7 +107,7 @@ In all case, you first need to install the ooor gem:
 Let's test OOOR in an irb console (irb command):
     $ require 'rubygems'
     $ require 'ooor'
-    $ Ooor.new({:url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin'})
+    $ Ooor.new(:url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin')
 This should load all your OpenERP models into Ruby proxy Activeresource objects. Of course there are option to load only some models.
 Let's try to retrieve the user with id 1:
     $ ResUsers.find(1)
@@ -115,27 +117,7 @@ Let's try to retrieve the user with id 1:
     
 ### (J)Ruby on Rails application:
 
-we assume you created a working Rails application, in your config/environment.rb
-Inside the Rails::Initializer.run do |config| statement, paste the following gem dependency:
-
-    $ config.gem "ooor"
-
-Now, you should also create a ooor.yml config file in your config directory
-You can copy/paste [the default ooor.yml from the OOOR gem](http://github.com/rvalyi/ooor/blob/master/ooor.yml)
-and then adapt it to your OpenERP server environment.
-If you set the 'bootstrap' parameter to true, OpenERP models will be loaded at the Rails startup.
-That the easiest option to get started while you might not want that in production.
-
-Then just start your Rails application, your OpenERP models will be loaded as you'll see in the Rails log.
-You can then use all the OOOR API upon all loaded OpenERP models in your regular Rails code (see API usage section).
-A good way to start playing with OOOR is inside the console, using:
-    $ ruby script/console #or jruby script/console on JRuby of course
-
-Note: when boostraping Ooor in a Rails application, the default Ooor instance is stored in the Ooor.default_ooor variable.
-So for instance you can know all loaded models doing Ooor.default_ooor variable.loaded_models; this is used by [OooREST](http://github.com/rvalyi/ooorest) to register all the REST controllers.
-
-Enabling REST HTTP routes to your OpenERP models:
-The REST Controller layer of OOOR has been moved as a thin separate gem called [OooREST](http://github.com/rvalyi/ooorest).
+Please read details [https://github.com/rvalyi/ooor/wiki/(J)Ruby-on-Rails-application](here)
 
 
 API usage
@@ -243,7 +225,8 @@ On Change methods:
 
 Note: currently OOOR doesn't deal with the View layer, or has a very limited support for forms for the wizards.
 So, it's not possible so far for OOOR to know an on_change signature. Because of this, the on_change syntax is  bit awkward
-as you will see: you need to explicitely tell the on_change name, the parameter name that changed, the new value and finally
+as you will see (fortunately OpenERP SA announced they will fix that on_change API in subsequent v6 OpenERP releases):
+you need to explicitely tell the on_change name, the parameter name that changed, the new value and finally
 enfore the on_change syntax (looking at the OpenERP model code or view or XML/RPC logs will help you to find out). But
 ultimately it works:
 
@@ -340,47 +323,4 @@ In this case [CampToCamp](http://www.camptocamp.com/) used the famous [Cucumber
 FAQ
 ------------
 
-### How do I know which object or OpenERP webservice I should Invoke from OOOR?
-
-An easy is to use your GTK client and start it with the -l debug_rpc (or alternatively -l debug_rpc_answer) option.
-For non *nix users, you can alternatively start your server with the --log-level=debug_rpc option (you can also set this option in your hidden OpenERP server config file in your user directory).
-Then create indents in the log before doing some action and watch your logs carefully. OOOR will allow you to do the same easily from Ruby/Rails.
-
-### How can I load/reload my OpenERP models into my Ruby application?
-
-You can load/reload your models at any time (even in console), creating a new Ooor instance that will override the class definitions:
-    $ Ooor.new({:url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin'})
-or using a config YAML file instead:
-    $ Ooor.new("config/ooor.yml")
-
-### Do I need to load all the OpenERP models in my Ruby application?
-
-You can load only some OpenERP models (not all), which is faster and better in term of memory/security:
-    $ Ooor.reload!({:models => [res.partner, product.template, product.product], :url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin'})
-
-### Isn't OOOR slow?
-
-You might think that proxying a Python based server through a Rails app using XML/RPC would be dog slow. Well, not too much actually.
-I did some load testing using a Centrino Duo laptop (dual core at 1.6 GHz), and I was able to approach 10 requests/sec, to display some OpenERP resource as XML through HTTP.
-That should be enough for what it's meant too. Heavily loaded application might cache things at the Rails level if that's too slow, but I don't think so.
-
-Also notice that using JRuby I could serve some 20% faster.
-
-### JRuby compatibility
-
-Yes Ooor is fully JRuby compatible. It's even somewhat 20% faster using Java6 + last JRuby.
-This might be espcially interresting if you plan to mix Java libraries with OpenERP in the same web appication.
-
-### Can I extend the OOOR models?
-
-Yes you can perfectly do that. Basically an OpenERP model get a basic ActiveResource model. For instance: product.product is mapped to the ProductProduct ActiveResource model.
-But using the Ruby open classes features, you can asbolutely re-open the ProductProduct class and add features of your own.
-In you app/model directory, create a product_product.rb file with inside, the redéfinition of ProductProduct, for instance:
-
-    $ class ProductProduct < OpenObjectResource
-    $   def foo
-    $     "bar"
-    $   end
-    $ end
-
-Now a ProductProduct resource got a method foo, returning "bar".
+Please read the [FAQ here](https://github.com/rvalyi/ooor/wiki/FAQ)

data/lib/app/models/base64.rb

@@ -1,5 +1,5 @@
 #    OOOR: Open Object On Rails
-#    Copyright (C) 2009-2010 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-2011 Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #
 #    This program is free software: you can redistribute it and/or modify

data/lib/app/models/common_service.rb

@@ -1,5 +1,5 @@
 #    OOOR: Open Object On Rails
-#    Copyright (C) 2009-2010 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-2011 Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #
 #    This program is free software: you can redistribute it and/or modify
@@ -16,27 +16,28 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #proxies all 'common' class of OpenERP server/bin/service/web_service.py properly
-module CommonService
-  def global_login(user, password)
-    @config[:username] = user
-    @config[:password] = password
-    client = OpenObjectResource.client(@base_url + "/common")
-    @config[:user_id] = OpenObjectResource.try_with_pretty_error_log { client.call("login", @config[:database], user, password) }
-    rescue Exception => error
-      @logger.error """login to OpenERP server failed:
-       #{error.inspect}
-       Are your sure the server is started? Are your login parameters correct? Can this server ping the OpenERP server?
-       login XML/RPC url was #{@config[:url].gsub(/\/$/,'') + "/common"}"""
-      raise
-  end
+module Ooor
+  module CommonService
+    def global_login(user, password)
+      @config[:username] = user
+      @config[:password] = password
+      @config[:user_id] = OpenObjectResource.client(@base_url + "/common").call("login", @config[:database], user, password)
+      rescue Exception => error
+        @logger.error """login to OpenERP server failed:
+         #{error.inspect}
+         Are your sure the server is started? Are your login parameters correct? Can this server ping the OpenERP server?
+         login XML/RPC url was #{@config[:url].gsub(/\/$/,'') + "/common"}"""
+        raise
+    end
 
-  def login(user, password); global_login(user, password); end
+    def login(user, password); global_login(user, password); end
 
-  #we generate methods handles for use in auto-completion tools such as jirb_swing
-  [:ir_get, :ir_set, :ir_del, :about, :logout, :timezone_get, :get_available_updates, :get_migration_scripts, :get_server_environment, :login_message, :check_connectivity].each do |meth|
-    self.instance_eval do
-      define_method meth do |*args|
-        OpenObjectResource.try_with_pretty_error_log { OpenObjectResource.client(@base_url + "/common").call(meth.to_s, *args) }
+    #we generate methods handles for use in auto-completion tools such as jirb_swing
+    [:ir_get, :ir_set, :ir_del, :about, :logout, :timezone_get, :get_available_updates, :get_migration_scripts, :get_server_environment, :login_message, :check_connectivity].each do |meth|
+      self.instance_eval do
+        define_method meth do |*args|
+          OpenObjectResource.client(@base_url + "/common").call(meth.to_s, *args)
+        end
       end
     end
   end

data/lib/app/models/db_service.rb

@@ -1,5 +1,5 @@
 #    OOOR: Open Object On Rails
-#    Copyright (C) 2009-2010 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-2011 Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #
 #    This program is free software: you can redistribute it and/or modify
@@ -16,28 +16,30 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #proxies all 'db' class of OpenERP server/bin/service/web_service.py properly
-module DbService
-  def create(password=@config[:db_password], db_name='ooor_db', demo=true, lang='en_US', user_password=@config[:password] || 'admin')
-    process_id = OpenObjectResource.try_with_pretty_error_log { OpenObjectResource.client(@base_url + "/db").call("create", password, db_name, demo, lang, user_password) }
-    @config[:database] = db_name
-    @config[:username] = 'admin'
-    @config[:passowrd] = user_password
-    while get_progress('admin', process_id) == [0, []]
-      @logger.info "..."
-      sleep(0.5)
+module Ooor
+  module DbService
+    def create(password=@config[:db_password], db_name='ooor_db', demo=true, lang='en_US', user_password=@config[:password] || 'admin')
+      process_id = OpenObjectResource.client(@base_url + "/db").call("create", password, db_name, demo, lang, user_password)
+      @config[:database] = db_name
+      @config[:username] = 'admin'
+      @config[:passowrd] = user_password
+      while get_progress('admin', process_id) == [0, []]
+        @logger.info "..."
+        sleep(0.5)
+      end
+      load_models()
     end
-    load_models()
-  end
 
-  def drop(password=@config[:db_password], db_name='ooor_db')
-    OpenObjectResource.try_with_pretty_error_log { OpenObjectResource.client(@base_url + "/db").call("drop", password, db_name) }
-  end
+    def drop(password=@config[:db_password], db_name='ooor_db')
+      OpenObjectResource.client(@base_url + "/db").call("drop", password, db_name)
+    end
 
-  #we generate methods handles for use in auto-completion tools such as jirb_swing
-  [:get_progress, :dump, :restore, :rename, :db_exist, :list, :change_admin_password, :list_lang, :server_version, :migrate_databases].each do |meth|
-    self.instance_eval do
-      define_method meth do |*args|
-        OpenObjectResource.try_with_pretty_error_log { OpenObjectResource.client(@base_url + "/db").call(meth.to_s, *args) }
+    #we generate methods handles for use in auto-completion tools such as jirb_swing
+    [:get_progress, :dump, :restore, :rename, :db_exist, :list, :change_admin_password, :list_lang, :server_version, :migrate_databases].each do |meth|
+      self.instance_eval do
+        define_method meth do |*args|
+          OpenObjectResource.client(@base_url + "/db").call(meth.to_s, *args)
+        end
       end
     end
   end

data/lib/app/models/ooor_client.rb

@@ -0,0 +1,41 @@
+#    OOOR: Open Object On Rails
+#    Copyright (C) 2009-2011 Akretion LTDA (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, or (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'xmlrpc/client'
+
+module Ooor
+  class OOORClient < 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
+      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("#{ e }".gsub("wrong fault-structure: ", ""))
+      rescue SyntaxError
+        raise e
+      end
+      if openerp_error_hash.is_a? Hash
+        raise RuntimeError.new "\n\n*********** OpenERP Server ERROR ***********\n#{openerp_error_hash["faultCode"]}\n#{openerp_error_hash["faultString"]}********************************************\n."
+      else
+        raise e
+      end
+    end
+  end
+end

data/lib/app/models/open_object_resource.rb

@@ -1,5 +1,5 @@
 #    OOOR: Open Object On Rails
-#    Copyright (C) 2009-2010 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-2011 Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #
 #    This program is free software: you can redistribute it and/or modify
@@ -15,490 +15,404 @@
 #    You should have received a copy of the GNU Affero General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'xmlrpc/client'
 require 'rubygems'
 require 'active_resource'
 require 'app/ui/form_model'
 require 'app/models/uml'
+require 'app/models/ooor_client'
+require 'app/models/type_casting'
+require 'app/models/relation'
+
+module Ooor
+  class OpenObjectResource < ActiveResource::Base
+    #PREDEFINED_INHERITS = {'product.product' => 'product_tmpl_id'}
+    #include ActiveModel::Validations
+    include UML
+    include TypeCasting
+
+    # ******************** class methods ********************
+    class << self
+
+      cattr_accessor :logger
+      attr_accessor :openerp_id, :info, :access_ids, :name, :openerp_model, :field_ids, :state, #model class attributes associated to the OpenERP ir.model
+                    :fields, :fields_defined, :many2one_associations, :one2many_associations, :many2many_associations, :polymorphic_m2o_associations, :associations_keys,
+                    :database, :user_id, :scope_prefix, :ooor, :association
+
+      def class_name_from_model_key(model_key=self.openerp_model)
+        model_key.split('.').collect {|name_part| name_part.capitalize}.join
+      end
 
-class OpenObjectResource < ActiveResource::Base
-  include UML
-
-  # ******************** class methods ********************
-  class << self
-
-    cattr_accessor :logger
-    attr_accessor :openerp_id, :info, :access_ids, :name, :openerp_model, :field_ids, :state, #model class attributes assotiated to the OpenERP ir.model
-                  :fields, :fields_defined, :many2one_relations, :one2many_relations, :many2many_relations, :polymorphic_m2o_relations, :relations_keys,
-                  :database, :user_id, :scope_prefix, :ooor
-
-    def class_name_from_model_key(model_key=self.openerp_model)
-      model_key.split('.').collect {|name_part| name_part.capitalize}.join
-    end
-
-    #similar to Object#const_get but for OpenERP model key
-    def const_get(model_key)
-      klass_name = class_name_from_model_key(model_key)
-      klass = (self.scope_prefix ? Object.const_get(self.scope_prefix) : Object).const_defined?(klass_name) ? (self.scope_prefix ? Object.const_get(self.scope_prefix) : Object).const_get(klass_name) : @ooor.define_openerp_model({'model' => model_key}, self.scope_prefix)
-      klass.reload_fields_definition()
-      klass
-    end
+      #similar to Object#const_get but for OpenERP model key
+      def const_get(model_key)
+        klass_name = class_name_from_model_key(model_key)
+        klass = (self.scope_prefix ? Object.const_get(self.scope_prefix) : Object).const_defined?(klass_name) ? (self.scope_prefix ? Object.const_get(self.scope_prefix) : Object).const_get(klass_name) : @ooor.define_openerp_model({'model' => model_key}, self.scope_prefix)
+        klass.reload_fields_definition()
+        klass
+      end
 
-    def create(attributes = {}, context={}, default_get_list=false, reload=true)
-       self.new(attributes, default_get_list, context).tap { |resource| resource.save(context, reload) }
-    end
+      def create(attributes = {}, context={}, default_get_list=false, reload=true)
+        self.new(attributes, default_get_list, context).tap { |resource| resource.save(context, reload) }
+      end
 
-    def reload_fields_definition(force = false)
-      if force or not @fields_defined
-        @fields_defined = true
-        @fields = {}
-        rpc_execute("fields_get").each do |k, field|
-          case field['type']
-          when 'many2one'
-            @many2one_relations[k] = field
-          when 'one2many'
-            @one2many_relations[k] = field
-          when 'many2many'
-            @many2many_relations[k] = field
-          when 'reference'
-            @polymorphic_m2o_relations[k] = field
-          else
-            @fields[k] = field
+      def reload_fields_definition(force = false)
+        if force or not @fields_defined
+          @fields_defined = true
+          @fields = {}
+          rpc_execute("fields_get").each do |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
+  #            if ['integer', 'int8'].index(field['type'])
+  #              self.send :validates_numericality_of, k, :only_integer => true
+  #            elsif field['type'] == 'float'
+  #              self.send :validates_numericality_of, k
+  #            elsif field['type'] == 'char'
+  #              self.send :validates_length_of, k, :maximum => field['size'] || 128
+  #            end
+              @fields[k] = field if field['name'] != 'id'
+            end
+  #          if field["required"]
+  #            if field['type'] == 'many2one'
+  #              next if PREDEFINED_INHERITS[self.openerp_model] == k
+  #            end
+  #            self.send :validates_presence_of, k
+  #          end
           end
-        end
-        @relations_keys = @many2one_relations.keys + @one2many_relations.keys + @many2many_relations.keys + @polymorphic_m2o_relations.keys
-        (@fields.keys + @relations_keys).each do |meth| #generates method handlers for autompletion tools such as jirb_swing
-          unless self.respond_to?(meth)
-            self.instance_eval do
-              define_method meth do |*args|
-                self.send :method_missing, *[meth, *args]
+          @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 such as jirb_swing
+            unless self.respond_to?(meth)
+              self.instance_eval do
+                define_method meth do |*args|
+                  self.send :method_missing, *[meth, *args]
+                end
               end
             end
           end
+          logger.debug "#{fields.size} fields loaded in model #{self.name}"
         end
-        logger.info "#{fields.size} fields loaded in model #{self.class}"
       end
-    end
 
-    # ******************** remote communication ********************
+      # ******************** remote communication ********************
 
-    #OpenERP search method
-    def search(domain=[], offset=0, limit=false, order=false, context={}, count=false)
-      rpc_execute('search', domain, offset, limit, order, context, count)
-    end
-
-    def client(url)
-      @clients ||= {}
-      @clients[url] ||= XMLRPC::Client.new2(url, nil, 900)
-    end
-
-    #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
-    def rpc_execute(method, *args)
-      rpc_execute_with_object(@openerp_model, method, *args)
-    end
-
-    def rpc_execute_with_object(object, method, *args)
-      rpc_execute_with_all(@database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], object, method, *args)
-    end
-
-    #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
-    def rpc_execute_with_all(db, uid, pass, obj, method, *args)
-      clean_request_args!(args)
-      logger.debug "rpc_execute_with_all: rpc_method: 'execute', db: #{db.inspect}, uid: #{uid.inspect}, pass: #{pass.inspect}, obj: #{obj.inspect}, method: #{method}, *args: #{args.inspect}"
-      try_with_pretty_error_log { cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/object").call("execute",  db, uid, pass, obj, method, *args)) }
-    end
-
-     #corresponding method for OpenERP osv.exec_workflow(self, db, uid, obj, method, *args)
-    def rpc_exec_workflow(action, *args)
-      rpc_exec_workflow_with_object(@openerp_model, action, *args)
-    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 relation; @relation ||= Relation.new(self); 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 client(url)
+        @clients ||= {}
+        @clients[url] ||= OOORClient.new2(url, nil, 900)
+      end
 
-    def rpc_exec_workflow_with_object(object, action, *args)
-      rpc_exec_workflow_with_all(@database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], object, action, *args)
-    end
+      #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
+      def rpc_execute(method, *args)
+        rpc_execute_with_object(@openerp_model, method, *args)
+      end
 
-    def rpc_exec_workflow_with_all(db, uid, pass, obj, action, *args)
-      clean_request_args!(args)
-      logger.debug "rpc_execute_with_all: rpc_method: 'exec_workflow', db: #{db.inspect}, uid: #{uid.inspect}, pass: #{pass.inspect}, obj: #{obj.inspect}, action: #{action}, *args: #{args.inspect}"
-      try_with_pretty_error_log { cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/object").call("exec_workflow", db, uid, pass, obj, action, *args)) }
-    end
+      def rpc_execute_with_object(object, method, *args)
+        rpc_execute_with_all(@database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], object, method, *args)
+      end
 
-    def old_wizard_step(wizard_name, ids, step='init', wizard_id=nil, form={}, context={}, report_type='pdf')
-      context = @ooor.global_context.merge(context)
-      cast_request_to_openerp!(form)
-      unless wizard_id
-        logger.debug "rpc_execute_with_all: rpc_method: 'create old_wizard_step' #{wizard_name}"
-        wizard_id = try_with_pretty_error_log { cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/wizard").call("create",  @database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], wizard_name)) }
+      #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
+      def rpc_execute_with_all(db, uid, pass, obj, method, *args)
+        clean_request_args!(args)
+        reload_fields_definition()
+        logger.debug "OOOR RPC: rpc_method: 'execute', db: #{db}, uid: #{uid}, pass: #, obj: #{obj}, method: #{method}, *args: #{args.inspect}"
+        cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/object").call("execute",  db, uid, pass, obj, method, *args))
       end
-      params = {'model' => @openerp_model, 'form' => form, 'report_type' => report_type}
-      params.merge!({'id' => ids[0], 'ids' => ids}) if ids
-      logger.debug "rpc_execute_with_all: rpc_method: 'execute old_wizard_step' #{wizard_id}, #{params.inspect}, #{step}, #{context}"
-      [wizard_id, try_with_pretty_error_log { cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/wizard").call("execute",  @database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], wizard_id, params, step, context)) }]
-    end
 
-    #grab the eventual error log from OpenERP response as OpenERP doesn't enforce carefuly
-    #the XML/RPC spec, see https://bugs.launchpad.net/openerp/+bug/257581
-    def try_with_pretty_error_log
-      yield
-      rescue RuntimeError => e
-        begin
-          openerp_error_hash = eval("#{ e }".gsub("wrong fault-structure: ", ""))
-        rescue SyntaxError
-          raise e
-        end
-        raise e unless openerp_error_hash.is_a? Hash
-        logger.error "*********** OpenERP Server ERROR:\n#{openerp_error_hash["faultString"]}***********"
-        raise RuntimeError.new('OpenERP server error')
-    end
+       #corresponding method for OpenERP osv.exec_workflow(self, db, uid, obj, method, *args)
+      def rpc_exec_workflow(action, *args)
+        rpc_exec_workflow_with_object(@openerp_model, action, *args)
+      end
 
-    def clean_request_args!(args)
-      if args[-1].is_a? Hash
-        args[-1] = @ooor.global_context.merge(args[-1])
-      elsif args.is_a?(Array)
-        args += [@ooor.global_context]
+      def rpc_exec_workflow_with_object(object, action, *args)
+        rpc_exec_workflow_with_all(@database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], object, action, *args)
       end
-      cast_request_to_openerp!(args[-2]) if args[-2].is_a? Hash
-    end
 
-    def cast_request_to_openerp!(map)
-      map.each do |k, v|
-        if v == nil
-          map[k] = false
-        elsif !v.is_a?(Integer) && !v.is_a?(Float) && v.is_a?(Numeric) && v.respond_to?(:to_f)
-          map[k] = 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
-          map[k] = "#{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
-          map[k] = "#{v.year}-#{v.month}-#{v.day}"
-        end
+      def rpc_exec_workflow_with_all(db, uid, pass, obj, action, *args)
+        clean_request_args!(args)
+        reload_fields_definition()
+        logger.debug "OOOR RPC: 'exec_workflow', db: #{db}, uid: #{uid}, pass: #, obj: #{obj}, action: #{action}, *args: #{args.inspect}"
+        cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/object").call("exec_workflow", db, uid, pass, obj, action, *args))
       end
-    end
 
-    def cast_answer_to_ruby!(answer)
-      reload_fields_definition()
-
-      def cast_map_to_ruby!(map)
-        map.each do |k, v|
-          if self.fields[k] && v.is_a?(String) && !v.empty?
-            case self.fields[k]['type']
-              when 'datetime'
-                map[k] = Time.parse(v)
-              when 'date'
-                map[k] = Date.parse(v)
-            end
-          end
+      def old_wizard_step(wizard_name, ids, step='init', wizard_id=nil, form={}, context={}, report_type='pdf')
+        context = @ooor.global_context.merge(context)
+        cast_request_to_openerp!(form)
+        unless wizard_id
+          logger.debug "OOOR RPC: 'create old_wizard_step' #{wizard_name}"
+          wizard_id = cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/wizard").call("create",  @database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], wizard_name))
         end
+        params = {'model' => @openerp_model, 'form' => form, 'report_type' => report_type}
+        params.merge!({'id' => ids[0], 'ids' => ids}) if ids
+        logger.debug "OOOR RPC: 'execute old_wizard_step' #{wizard_id}, #{params.inspect}, #{step}, #{context}"
+        [wizard_id, cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/wizard").call("execute",  @database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], wizard_id, params, step, context))]
       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
+      def method_missing(method_symbol, *arguments)        
+        raise RuntimeError.new("Invalid RPC method:  #{method_symbol}") if [:type!, :allowed!].index(method_symbol)
+        self.rpc_execute(method_symbol.to_s, *arguments)
       end
-    end
-
-    def method_missing(method_symbol, *arguments)
-      raise RuntimeError.new("Invalid RPC method:  #{method_symbol}") if [:type!, :allowed!].index(method_symbol)
-      self.rpc_execute(method_symbol.to_s, *arguments)
-    end
 
 
-    # ******************** finders low level implementation ********************
+      # ******************** finders low level implementation ********************
+      private
 
-    private
+      def find_every(options)
+        domain = options[:domain]
+        context = options[:context] || {}
+        prefix_options, domain = split_options(options[:params]) unless domain
+        ids = rpc_execute('search', to_openerp_domain(domain), options[:offset] || 0, options[:limit] || false,  options[:order] || false, context)
+        !ids.empty? && ids[0].is_a?(Integer) && find_single(ids, options) || []
+      end
 
-    def find_every(options)
-      domain = options[:domain]
-      context = options[:context] || {}
-      unless domain
+      #actually finds many resources specified with scope = ids_array
+      def find_single(scope, options)
+        fields = options[:fields] || options[:only] || []
+        context = options[:context] || {}
         prefix_options, query_options = split_options(options[:params])
-        domain = []
-        query_options.each_pair do |k, v|
-          domain.push [k.to_s, '=', v]
+        is_collection = true
+        scope = [scope] and is_collection = false if !scope.is_a? Array
+        scope.map! do |item|
+          if item.is_a?(String) && item.to_i == 0#triggers ir_model_data absolute reference lookup
+            tab = item.split(".")
+            domain = [['name', '=', tab[-1]]]
+            domain += [['module', '=', tab[-2]]] if tab[-2]
+            ir_model_data = const_get('ir.model.data').find(:first, :domain => domain)
+            ir_model_data && ir_model_data.res_id && search([['id', '=', ir_model_data.res_id]])[0]
+          else
+            item
+          end
+        end.reject! {|item| !item}
+        records = rpc_execute('read', scope, fields, context)
+        records = records.sort_by {|r| scope.index(r["id"])} #TODO use sort_by! in Ruby 1.9
+        active_resources = []
+        records.each do |record|
+          r = {}
+          record.each_pair do |k,v|
+            r[k.to_sym] = v
+          end
+          active_resources << instantiate_record(r, prefix_options, context)
         end
+        unless is_collection
+          return active_resources[0]
+        end
+        return active_resources
       end
-      ids = rpc_execute('search', domain, options[:offset] || 0, options[:limit] || false,  options[:order] || false, context)
-      !ids.empty? && ids[0].is_a?(Integer) && find_single(ids, options) || []
-    end
 
-    #actually finds many resources specified with scope = ids_array
-    def find_single(scope, options)
-      fields = options[:fields] || []
-      context = options[:context] || {}
-      prefix_options, query_options = split_options(options[:params])
-      is_collection = true
-      scope = [scope] and is_collection = false if !scope.is_a? Array
-      scope.map! do |item|
-        if item.is_a?(String) && item.to_i == 0#triggers ir_model_data absolute reference lookup
-          tab = item.split(".")
-          domain = [['name', '=', tab[-1]]]
-          domain += [['module', '=', tab[-2]]] if tab[-2]
-          ir_model_data = const_get('ir.model.data').find(:first, :domain => domain)
-          ir_model_data && ir_model_data.res_id && search([['id', '=', ir_model_data.res_id]])[0]
-        else
-          item
-        end
-      end.reject! {|item| !item}
-      records = rpc_execute('read', scope, fields, context)
-      active_resources = []
-      records.each do |record|
-        r = {}
-        record.each_pair do |k,v|
-          r[k.to_sym] = v
+      #overriden because loading default fields is all the rage but we don't want them when reading a record
+      def instantiate_record(record, prefix_options = {}, context = {})
+        new(record, [], context).tap do |resource|
+          resource.prefix_options = prefix_options
         end
-        active_resources << instantiate_record(r, prefix_options, context)
       end
-      unless is_collection
-        return active_resources[0]
-      end
-      return active_resources
-    end
 
-    #overriden because loading default fields is all the rage but we don't want them when reading a record
-    def instantiate_record(record, prefix_options = {}, context = {})
-      new(record, [], context).tap do |resource|
-        resource.prefix_options = prefix_options
-      end
     end
 
-  end
-
+    self.name = "OpenObjectResource"
+    
+    
+    # ******************** instance methods ********************
 
-  # ******************** instance methods ********************
+    attr_accessor :associations, :loaded_associations, :ir_model_data_id, :object_session
 
-  attr_accessor :relations, :loaded_relations, :ir_model_data_id, :object_session
-
-  def object_db; object_session[:database] || self.class.database || self.class.ooor.config[:database]; end
-  def object_uid;object_session[:user_id] || self.class.user_id || self.class.ooor.config[:user_id]; end
-  def object_pass; object_session[:password] || self.class.password || self.class.ooor.config[:password]; end
-  
-  #try to wrap the object context inside the query.
-  def rpc_execute(method, *args)
-	if args[-1].is_a? Hash
-    args[-1] = self.class.ooor.global_context.merge(object_session[:context]).merge(args[-1])
-  elsif args.is_a?(Array)
-    args += [self.class.ooor.global_context.merge(object_session[:context])]
-	end
-    self.class.rpc_execute_with_all(object_db, object_uid, object_pass, self.class.openerp_model, method, *args)
-  end
+    def object_db; object_session[:database] || self.class.database || self.class.ooor.config[:database]; end
+    def object_uid;object_session[:user_id] || self.class.user_id || self.class.ooor.config[:user_id]; end
+    def object_pass; object_session[:password] || self.class.password || self.class.ooor.config[:password]; end
 
-  def cast_relations_to_openerp!
-    @relations.reject! do |k, v| #reject non asigned many2one or empty list
-      v.is_a?(Array) && (v.size == 0 or v[1].is_a?(String))
+    #try to wrap the object context inside the query.
+    def rpc_execute(method, *args)
+    if args[-1].is_a? Hash
+      args[-1] = self.class.ooor.global_context.merge(object_session[:context]).merge(args[-1])
+    elsif args.is_a?(Array)
+      args += [self.class.ooor.global_context.merge(object_session[:context])]
+    end
+      self.class.rpc_execute_with_all(object_db, object_uid, object_pass, self.class.openerp_model, method, *args)
     end
 
-    def cast_relation(k, v, one2many_relations, many2many_relations)
-      if one2many_relations[k]
-        return v.collect! do |value|
-          if value.is_a?(OpenObjectResource) #on the fly creation as in the GTK client
-            [0, 0, value.to_openerp_hash!]
-          else
-            [1, value, {}]
+    def reload_from_record!(record) load(record.attributes, record.associations) end
+
+    def load(attributes, associations={})#an attribute might actually be a association too, will be determined here
+      self.class.reload_fields_definition()
+      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+      @prefix_options, attributes = split_options(attributes)
+      @associations = associations
+      @attributes = {}
+      @loaded_associations = {}
+      attributes.each do |key, value|
+        skey = key.to_s
+        if self.class.associations_keys.index(skey) || value.is_a?(Array)
+          associations[skey] = value #the association because we want the method to load the association through method missing
+        else
+          case value
+            when Hash
+              resource = find_or_create_resource_for(key) #TODO check!
+              @attributes[skey] = resource@attributes[skey].new(value)
+            else
+              @attributes[skey] = value
           end
         end
-      elsif many2many_relations[k]
-        return v = [[6, 0, v]]
       end
+      self
     end
 
-    @relations.each do |k, v| #see OpenERP awkward relations API
-      #already casted, possibly before server error!
-      next if (v.is_a?(Array) && v.size == 1 && v[0].is_a?(Array)) \
-              || self.class.many2one_relations[k] \
-              || !v.is_a?(Array)
-      new_rel = self.cast_relation(k, v, self.class.one2many_relations, self.class.many2many_relations)
-      if new_rel #matches a known o2m or m2m
-        @relations[k] = new_rel
-      else
-        self.class.many2one_relations.each do |k2, field| #try to cast the relation to an inherited o2m or m2m:
-          linked_class = self.class.const_get(field['relation'])
-          new_rel = self.cast_relation(k, v, linked_class.one2many_relations, linked_class.many2many_relations)
-          @relations[k] = new_rel and break if new_rel
-        end
-      end
+    def load_association(model_key, ids, *arguments)
+      options = arguments.extract_options!
+      related_class = self.class.const_get(model_key)
+      related_class.send :find, ids, :fields => options[:fields] || options[:only] || [], :context => options[:context] || {}
     end
-  end
 
-  def reload_from_record!(record) load(record.attributes, record.relations) end
-
-  def load(attributes, relations={})#an attribute might actually be a relation too, will be determined here
-    self.class.reload_fields_definition()
-    raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
-    @prefix_options, attributes = split_options(attributes)
-    @relations = relations
-    @attributes = {}
-    @loaded_relations = {}
-    attributes.each do |key, value|
-      skey = key.to_s
-      if self.class.relations_keys.index(skey) || value.is_a?(Array)
-        relations[skey] = value #the relation because we want the method to load the association through method missing
+    def available_fields
+      msg = "\n*** AVAILABLE FIELDS ON OBJECT #{self.class.name} ARE: ***"
+      msg << "\n\n" << self.class.fields.sort {|a,b| a[1]['type']<=>b[1]['type']}.map {|i| "#{i[1]['type']} --- #{i[0]}"}.join("\n")
+      msg << "\n\n" << self.class.many2one_associations.map {|k, v| "many2one --- #{v['relation']} --- #{k}"}.join("\n")
+      msg << "\n\n" << self.class.one2many_associations.map {|k, v| "one2many --- #{v['relation']} --- #{k}"}.join("\n")
+      msg << "\n\n" << self.class.many2many_associations.map {|k, v| "many2many --- #{v['relation']} --- #{k}"}.join("\n")
+      msg << "\n\n" << self.class.polymorphic_m2o_associations.map {|k, v| "polymorphic_m2o --- #{v['relation']} --- #{k}"}.join("\n")
+    end
+
+    #takes care of reading OpenERP default field values.
+    def initialize(attributes = {}, default_get_list=false, context={})
+      @attributes = {}
+      @prefix_options = {}
+      @ir_model_data_id = attributes.delete(:ir_model_data_id)
+      @object_session = {}
+      @object_session[:user_id] = context.delete :user_id
+      @object_session[:database] = context.delete :database
+      @object_session[:password] = context.delete :password
+      @object_session[:context] = context
+      if default_get_list == []
+        load(attributes)
       else
-        case value
-          when Hash
-            resource = find_or_create_resource_for(key) #TODO check!
-            @attributes[skey] = resource@attributes[skey].new(value)
-          else
-            @attributes[skey] = value
-        end
+        self.class.reload_fields_definition()
+        attributes = rpc_execute("default_get", default_get_list || self.class.fields.keys + self.class.associations_keys, @object_session[:context]).symbolize_keys!.merge(attributes.symbolize_keys!)
+        load(attributes)
       end
     end
-    self
-  end
-
-  def load_relation(model_key, ids, *arguments)
-    options = arguments.extract_options!
-    related_class = self.class.const_get(model_key)
-    related_class.send :find, ids, :fields => options[:fields] || [], :context => options[:context] || {}
-  end
 
-  def display_available_fields
-    msg = "\n*** AVAILABLE FIELDS ON OBJECT #{self} ARE: ***"
-    msg << "\n\n" << self.class.fields.sort {|a,b| a[1]['type']<=>b[1]['type']}.map {|i| "#{i[1]['type']} --- #{i[0]}"}.join("\n")
-    msg << "\n\n" << self.class.many2one_relations.map {|k, v| "many2one --- #{v['relation']} --- #{k}"}.join("\n")
-    msg << "\n\n" << self.class.one2many_relations.map {|k, v| "one2many --- #{v['relation']} --- #{k}"}.join("\n")
-    msg << "\n\n" << self.class.many2many_relations.map {|k, v| "many2many --- #{v['relation']} --- #{k}"}.join("\n")
-    msg << "\n\n" << self.class.polymorphic_m2o_relations.map {|k, v| "polymorphic_m2o --- #{v['relation']} --- #{k}"}.join("\n")
-    self.class.logger.debug msg
-  end
-
-  def to_openerp_hash!
-    cast_relations_to_openerp!
-    @attributes.reject {|key, value| key == 'id'}.merge(@relations)
-  end
-
-  #takes care of reading OpenERP default field values.
-  def initialize(attributes = {}, default_get_list=false, context={})
-    @attributes = {}
-    @prefix_options = {}
-    @ir_model_data_id = attributes.delete(:ir_model_data_id)
-    @object_session = {}
-    @object_session[:user_id] = context.delete :user_id
-    @object_session[:database] = context.delete :database
-    @object_session[:password] = context.delete :password
-    @object_session[:context] = context
-    if default_get_list == []
-      load(attributes)
-    else
-      self.class.reload_fields_definition()
-      load(rpc_execute("default_get", default_get_list || self.class.fields.keys + self.class.relations_keys, @object_session[:context]).symbolize_keys!.merge(attributes.symbolize_keys!))
+    def save(context={}, reload=true)
+      new? ? create(context, reload) : update(context, reload)
     end
-  end
-
-  def save(context={}, reload=true)
-    new? ? create(context, reload) : update(context, reload)
-  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)
-    IrModelData.create(:model => self.class.openerp_model, :module => @ir_model_data_id[0], :name=> @ir_model_data_id[1], :res_id => self.id) if @ir_model_data_id
-    reload_from_record!(self.class.find(self.id, :context => context)) if reload
-  end
-
-  #compatible with the Rails way but also supports OpenERP context
-  def update(context={}, reload=true)
-    rpc_execute('write', [self.id], to_openerp_hash!, context)
-    reload_from_record!(self.class.find(self.id, :context => context)) if reload
-  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
+    #compatible with the Rails way but also supports OpenERP context
+    def create(context={}, reload=true)
+      self.id = rpc_execute('create', to_openerp_hash!, context)
+      IrModelData.create(:model => self.class.openerp_model, :module => @ir_model_data_id[0], :name=> @ir_model_data_id[1], :res_id => self.id) if @ir_model_data_id
+      reload_from_record!(self.class.find(self.id, :context => context)) if reload
+    end
 
-  #Generic OpenERP on_change method
-  def on_change(on_change_method, field_name, field_value, *args)
-    result = self.class.rpc_execute_with_all(object_db, object_uid, object_pass, self.class.openerp_model, on_change_method, self.id && [id] || [], *args) #OpenERP doesn't accept context systematically in on_change events unfortunately
-    if result["warning"]
-      self.class.logger.info result["warning"]["title"]
-      self.class.logger.info result["warning"]["message"]
+    #compatible with the Rails way but also supports OpenERP context
+    def update(context={}, reload=true)
+      rpc_execute('write', [self.id], to_openerp_hash!, context)
+      reload_from_record!(self.class.find(self.id, :context => context)) if reload
     end
-    load(@attributes.merge({field_name => field_value}).merge(result["value"]), @relations)
-  end
 
-  #wrapper for OpenERP exec_workflow Business Process Management engine
-  def wkf_action(action, context={}, reload=true)
-    self.class.rpc_exec_workflow_with_all(object_db, object_uid, object_pass, self.class.openerp_model, action, self.id) #FIXME looks like OpenERP exec_workflow doesn't accept context but it might be a bug
-    reload_from_record!(self.class.find(self.id, :context => context)) if reload
-  end
+    #compatible with the Rails way but also supports OpenERP context
+    def destroy(context={})
+      rpc_execute('unlink', [self.id], context)
+    end
 
-  def old_wizard_step(wizard_name, step='init', wizard_id=nil, form={}, context={})
-    result = self.class.old_wizard_step(wizard_name, [self.id], step, wizard_id, form, {})
-    FormModel.new(wizard_name, result[0], nil, nil, result[1], [self], self.class.ooor.global_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
 
-  def type() method_missing(:type) end #skips deprecated Object#type method
+    #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)
+      result = self.class.rpc_execute_with_all(object_db, object_uid, object_pass, self.class.openerp_model, on_change_method, self.id && [id] || [], *args) #OpenERP doesn't accept context systematically in on_change events unfortunately
+      if result["warning"]
+        self.class.logger.info result["warning"]["title"]
+        self.class.logger.info result["warning"]["message"]
+      end
+      load(@attributes.merge({field_name => field_value}).merge(result["value"]), @associations)
+    end
 
-  # ******************** fake associations like much like ActiveRecord according to the cached OpenERP data model ********************
+    #wrapper for OpenERP exec_workflow Business Process Management engine
+    def wkf_action(action, context={}, reload=true)
+      self.class.rpc_exec_workflow_with_all(object_db, object_uid, object_pass, self.class.openerp_model, action, self.id) #FIXME looks like OpenERP exec_workflow doesn't accept context but it might be a bug
+      reload_from_record!(self.class.find(self.id, :context => context)) if reload
+    end
 
-  def relationnal_result(method_name, *arguments)
-    self.class.reload_fields_definition()
-    if self.class.many2one_relations.has_key?(method_name)
-      load_relation(self.class.many2one_relations[method_name]['relation'], @relations[method_name].is_a?(Integer) && @relations[method_name] || @relations[method_name][0], *arguments)
-    elsif self.class.one2many_relations.has_key?(method_name)
-      load_relation(self.class.one2many_relations[method_name]['relation'], @relations[method_name], *arguments)
-    elsif self.class.many2many_relations.has_key?(method_name)
-      load_relation(self.class.many2many_relations[method_name]['relation'], @relations[method_name], *arguments)
-    elsif self.class.polymorphic_m2o_relations.has_key?(method_name)
-      values = @relations[method_name].split(',')
-      load_relation(values[0], values[1].to_i, *arguments)
-    else
-      false
+    def old_wizard_step(wizard_name, step='init', wizard_id=nil, form={}, context={})
+      result = self.class.old_wizard_step(wizard_name, [self.id], step, wizard_id, form, {})
+      FormModel.new(wizard_name, result[0], nil, nil, result[1], [self], self.class.ooor.global_context)
     end
-  end
+    
+    def log(message, context={}) rpc_execute('log', id, message, context) end
+
+    def type() method_missing(:type) end #skips deprecated Object#type method
 
-  def method_missing(method_symbol, *arguments)
-    method_name = method_symbol.to_s
-    is_assign = method_name.end_with?('=')
-    method_key = method_name.sub('=', '')
-    return super if attributes.has_key?(method_key)
-    return rpc_execute(method_name, *arguments) unless arguments.empty? || is_assign
-
-    self.class.reload_fields_definition()
-
-    if is_assign
-      known_relations = self.class.relations_keys + self.class.many2one_relations.collect {|k, field| self.class.const_get(field['relation']).relations_keys}.flatten
-      if known_relations.index(method_key)
-        @relations[method_key] = arguments[0]
-        @loaded_relations[method_key] = arguments[0]
-        return
+    # fakes associations like much like ActiveRecord according to the cached OpenERP data model
+    def relationnal_result(method_name, *arguments)
+      self.class.reload_fields_definition()
+      if self.class.many2one_associations.has_key?(method_name)
+        load_association(self.class.many2one_associations[method_name]['relation'], @associations[method_name].is_a?(Integer) && @associations[method_name] || @associations[method_name][0], *arguments)
+      elsif self.class.one2many_associations.has_key?(method_name)
+        load_association(self.class.one2many_associations[method_name]['relation'], @associations[method_name], *arguments) || []
+      elsif self.class.many2many_associations.has_key?(method_name)
+        load_association(self.class.many2many_associations[method_name]['relation'], @associations[method_name], *arguments) || []
+      elsif self.class.polymorphic_m2o_associations.has_key?(method_name)
+        values = @associations[method_name].split(',')
+        load_association(values[0], values[1].to_i, *arguments)
+      else
+        false
       end
-      know_fields = self.class.fields.keys + self.class.many2one_relations.collect {|k, field| self.class.const_get(field['relation']).fields.keys}.flatten
-      @attributes[method_key] = arguments[0] and return if know_fields.index(method_key)
     end
+    
+    def method_missing(method_symbol, *arguments)      
+      method_name = method_symbol.to_s
+      is_assign = method_name.end_with?('=')
+      method_key = method_name.sub('=', '')
+      self.class.reload_fields_definition()
 
-    return @loaded_relations[method_name] if @loaded_relations.has_key?(method_name)
-    return false if @relations.has_key?(method_name) and (!@relations[method_name] || @relations[method_name].is_a?(Array) && !@relations[method_name][0])
+      if attributes.has_key?(method_key)
+        return super
+      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 self.class.fields.has_key?(method_key) || self.class.associations_keys.index(method_name) #unloaded field/association
+        load(rpc_execute('read', [id], [method_key], *arguments)[0] || {})
+        return method_missing(method_key, *arguments)
+      elsif is_assign
+        known_associations = self.class.associations_keys + self.class.many2one_associations.collect {|k, field| self.class.const_get(field['relation']).associations_keys}.flatten
+        if known_associations.index(method_key)
+          @associations[method_key] = arguments[0]
+          @loaded_associations[method_key] = arguments[0]
+          return
+        end
+        know_fields = self.class.fields.keys + self.class.many2one_associations.collect {|k, field| self.class.const_get(field['relation']).fields.keys}.flatten
+        @attributes[method_key] = arguments[0] and return if know_fields.index(method_key)
+      elsif id #it's an action
+        arguments += [{}] unless arguments.last.is_a?(Hash)
+        rpc_execute(method_key, [id], *arguments) #we assume that's an action
+      else
+        super
+      end
 
-    if self.class.relations_keys.index(method_name) && !@relations[method_name]
-      return self.class.many2one_relations.index(method_name) ? nil : []
-    end
-    result = relationnal_result(method_name, *arguments)
-    @loaded_relations[method_name] = result and return result if result
-
-    if id
-      arguments += [{}] unless arguments.last.is_a?(Hash)
-      rpc_execute(method_key, [id], *arguments) #we assume that's an action
-    else
-      super
+    rescue RuntimeError => e
+      e.message << "\n" + available_fields if e.message.index("AttributeError")
+      raise e
     end
 
-  rescue RuntimeError
-    raise
-  rescue NoMethodError
-    display_available_fields
-    raise
   end
-
-end
+end