ooor 1.1.0 → 1.2.0

data/README.md

@@ -76,7 +76,7 @@ OOOR also extends ActiveResource a bit with special request parameters (like :do
 Installation
 ------------
 
-You can use OOOR in a standalone (J)Ruby application, or in a Rails application.
+You can use OOOR in a standalone (J)Ruby application, or in a Rails application, it only depends on the activeresource gem.
 For both example we assume that you already started some OpenERP server on localhost, with XML/RPC on port 8069 (default),
 with a database called 'mybase', with username 'admin' and password 'admin'.
 
@@ -91,8 +91,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'
-    $ include Ooor
-    $ Ooor.reload!({: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)
@@ -116,13 +115,11 @@ You can then use all the OOOR API upon all loaded OpenERP models in your regular
 A good way to start playing with OOOR is inside the console, using:
     $ ruby script/console #or jruby script/console on JRuby of course
 
-Enabling REST HTTP routes to your OpenERP models:
-in your config/route.rb, you can alternatively enable routes to all your OpenERP models by addding:
-    $ OpenObjectsController.load_all_controllers(map)
-
-Or only enable the route to some specific model instead (here partners):
-    $ map.resources :res_partner
+Note: when boostraping Ooor in a Rails application, the default Ooor instance is stored in the OOOR constant.
+So for instance you can know all loaded models doing OOOR.all_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).
 
 
 API usage
@@ -140,15 +137,15 @@ Basic finders:
     $ ProductProduct.find(:last)
 
 
-OpenERP domain support:
+OpenERP domain support (same as OpenERP):
 
     $ ResPartner.find(:all, :domain=>[['supplier', '=', 1],['active','=',1]])
-More subbtle now, remember OpenERP use a kind of inverse polish notation for complex domains,
+More subtle now, remember OpenERP use a kind of inverse polish notation for complex domains,
 here we look for a product in category 1 AND which name is either 'PC1' OR 'PC2':
     $ ProductProduct.find(:all, :domain=>[['categ_id','=',1],'|',['name', '=', 'PC1'],['name','=','PC2']])
 
 
-OpenERP context support:
+OpenERP context support (same as OpenERP):
 
     $ ProductProduct.find(1, :context => {:my_key => 'value'})
 
@@ -166,10 +163,11 @@ Arguments are: domain, offset=0, limit=false, order=false, context={}, count=fal
 
 Relations (many2one, one2many, many2many) support:
 
-    $ SaleOrder.find(1).order_line
+    $ SaleOrder.find(1).order_line #one2many relation
     $ p = ProductProduct.find(1)
     $ p.product_tmpl_id #many2one relation
-    $ p.product_tmpl_id.taxes_id = [6, 0, [1,2]] #create many2many associations,
+    $ p.taxes_id #automagically reads man2many relation inherited via the product_tmpl_id inheritance relation
+    $ p.taxes_id = [1,2] #save a many2many relation, notice how we bypass the awkward OpenERP syntax for many2many (would require [6,0, [1,2]]) ,
     $ p.save #assigns taxes with id 1 and 2 as sale taxes,
 see [the official OpenERP documentation](http://doc.openerp.com/developer/5_18_upgrading_server/19_1_upgrading_server.html?highlight=many2many)
 
@@ -180,9 +178,6 @@ Inherited relations support:
 
 Please notice that loaded relations are cached (to avoid  hitting OpenERP over and over)
 until the root object is reloaded (after save/update for instance).
-Currently, save/update doesn't save the whole object graph but only the current object.
-We might change this in the future to match the way OpenERP clients are working which
-is supported by the OpenERP ORM, see issue: http://github.com/rvalyi/ooor/issues/#issue/3
 
 
 Load only specific fields support (faster than loading all fields):
@@ -229,26 +224,48 @@ Call workflow:
 
 On Change methods:
 
-    $ l=SaleOrderLine.new
-    $ l.on_change('product_id_change', 1, 1, false, false, false, false, false, false, 1)
-    $ => #<Ooor::SaleOrderLine:0x10c2cfe1 @prefix_options={}, @attributes={"product_packaging"=>false, "product_uos_qty"=>false, "th_weight"=>0}>
+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
+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:
+
+    $ l = SaleOrderLine.new
+    $ l.on_change('product_id_change', :product_id, 20, 1, 20, 1, false, 1, false, false, 7, 'en_US', true, false, false, false)
+    $ => #<SaleOrderLine:0x7f76118b4348 @prefix_options={}, @relations={"product_uos"=>false, "product_id"=>20, "product_uom"=>1, "tax_id"=>[]}, @loaded_relations={}, @attributes={"name"=>"[TOW1] ATX Mid-size Tower", "product_uos_qty"=>1, "delay"=>1.0, "price_unit"=>37.5, "type"=>"make_to_stock", "th_weight"=>0}>
 Notice that it reloads the Objects attrs and print warning message accordingly
 
 
+On the fly one2many object graph update/creation:
+
+Just like the OpenERP GTK client (and unlike the web client), in OOOR you can pass create/update
+one2many relation in place directly. For instance:
+    $ so = SaleOrder.new
+    $ so.on_change('onchange_partner_id', :partner_id, 1, 1, false) #auto-complete the address and other data based on the partner
+    $ so.order_line = [SaleOrderLine.new(:name => 'sl1', :product_id => 1, :price_unit => 42, :product_uom => 1)] #create one order line
+    $ so.save
+    $ so.amount_total
+    $ => 42.0
+
+
 Call aribtrary method:
 
     $ use static ObjectClass.rpc_execute_with_all method
     $ or object.call(method_name, args*) #were args is an aribtrary list of arguments
-    $ or use the method missing wrapper that will proxy any OpenERP osv.py/orm.py method, see fo instance:
+
+Class methods from are osv.py/orm.py proxied to OpenERP directly (as the web client does):
     $ ResPartner.name_search('ax', [], 'ilike', {})
     $ ProductProduct.fields_view_get(132, 'tree', {})
 
 
-Call old wizards:
+Call old style wizards:
 
     $ inv = AccountInvoice.find(4)
+    $ #in case the inv.state is 'draft', do inv.wkf_action('invoice_open')
     $ wizard = inv.old_wizard_step('account.invoice.pay') #tip: you can inspect the wizard fields, arch and datas
     $ wizard.reconcile({:journal_id => 6, :name =>"from_rails"}) #if you want to pay all; will give you a reloaded invoice
+    $ inv.state
+    $ => "paid"
     $ #or if you want a payment with a write off:
     $ wizard.writeoff_check({"amount" => 12, "journal_id" => 6, "name" =>'from_rails'}) #use the button name as the wizard method
     $ wizard.reconcile({required missing write off fields...}) #will give you a reloaded invoice because state is 'end'
@@ -274,21 +291,7 @@ However you might want to change that. 2 solutions:
     $ In the config yaml file or hash, set the :log_level parameter
 
 
-
-REST HTTP API:
-
-    $ http://localhost:3000/res_partner
-    $ http://localhost:3000/res_partner.xml
-    $ http://localhost:3000/res_partner.json
-    $ http://localhost:3000/res_partner/2
-    $ http://localhost:3000/res_partner/2.json
-    $ http://localhost:3000/res_partner/2.xml
-    $ http://localhost:3000/res_partner/[2,3,4].xml
-    $ http://localhost:3000/res_partner/[2,3,4].json
-
-    $ TODO http://localhost:3000/res_partner.xml?active=1
-
-    $ TODO http://localhost:3000/res_partner.xml?domain=TODO
+[Drawing OpenERP UML diagrams with OOOR](http://wiki.github.com/rvalyi/ooor/drawing-openerp-uml-diagrams-with-ooor)
 
 
 FAQ
@@ -302,17 +305,16 @@ Then create indents in the log before doing some action and watch your logs care
 
 ### How can I load/reload my OpenERP models into my Ruby application?
 
-You can load/reload your models at any time (even in console), using the Ooor.reload! method, for instance:
-    $ Ooor.reload!({:url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin'})
+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.reload!("config/ooor.yml")
+    $ 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.
@@ -338,18 +340,4 @@ In you app/model directory, create a product_product.rb file with inside, the re
     $   end
     $ end
 
-Now a ProductProduct resource got a method foo, returning "bar".
-
-### Can I extend the OOOR controllers?
-
-Yes, you can do that, see the "how to extends models" section as it's very similar. Instead, in the app/controllers directory, you'll re-open defined controllers,
-for the product.product controllers, it means creating a product_product_controller.rb file with:
-
-    $ class ProductProduct < OpenObjectsController
-    $   def foo
-    $     render :text => "bar"
-    $   end
-    $ end
-
-Now, if you register that new method in your route.rb file GET /product_product/1/foo will render "bar" on your browser screen.
-You could instead just customize the existing CRUD methods so you don't need to regiter any other route in route.rb.
+Now a ProductProduct resource got a method foo, returning "bar".

data/lib/app/models/open_object_resource.rb

@@ -1,30 +1,29 @@
 require 'xmlrpc/client'
-require 'activeresource'
+require 'active_resource'
 require 'app/models/open_object_ui'
+require 'app/models/uml'
 
 #TODO implement passing session credentials to RPC methods (concurrent access of different user credentials in Rails)
 
 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
-                  :field_defined, :many2one_relations, :one2many_relations, :many2many_relations,
-                  :openerp_database, :user_id
+                  :fields, :fields_defined, :many2one_relations, :one2many_relations, :many2many_relations,
+                  :openerp_database, :user_id, :scope_prefix, :ooor
 
-    def class_name_from_model_key(model_key)
-      model_key.split('.').collect {|name_part| name_part[0..0].upcase + name_part[1..-1]}.join
+    def class_name_from_model_key(model_key=self.openerp_model)
+      self.scope_prefix + model_key.split('.').collect {|name_part| name_part.capitalize}.join
     end
 
     def reload_fields_definition(force = false)
-      if self != IrModel and self != IrModelFields and (force or not @field_defined)#TODO have a way to force reloading @field_ids too eventually
-        fields = IrModelFields.find(@field_ids)
+      if not (self.to_s.match('IrModel') || self.to_s.match('IrModelFields')) and (force or not @fields_defined)#TODO have a way to force reloading @field_ids too eventually
+        fields = Object.const_get(self.scope_prefix + 'IrModelFields').find(@field_ids)
         @fields = {}
-        @many2one_relations = {}
-        @one2many_relations = {}
-        @many2many_relations = {}
         fields.each do |field|
           case field.attributes['ttype']
           when 'many2one'
@@ -37,38 +36,11 @@ class OpenObjectResource < ActiveResource::Base
             @fields[field.attributes['name']] = field
           end
         end
-        logger.info "#{fields.size} fields loaded"
+        logger.info "#{fields.size} fields loaded in model #{self.class}"
       end
-      @field_defined = true
+      @fields_defined = true
     end
 
-    def define_openerp_model(arg, url, database, user_id, pass, binding)
-      param = (arg.is_a? OpenObjectResource) ? arg.attributes.merge(arg.relations) : {'model' => arg}
-      model_key = param['model']
-      Ooor.all_loaded_models.push(model_key)
-      model_class_name = class_name_from_model_key(model_key)
-      logger.info "registering #{model_class_name} as a Rails ActiveResource Model wrapper for OpenObject #{model_key} model"
-      definition = "
-      class #{model_class_name} < OpenObjectResource
-        self.site = '#{url || Ooor.base_url}'
-        self.user = #{user_id}
-        self.password = #{pass || false}
-        self.openerp_database = '#{database}'
-        self.openerp_model = '#{model_key}'
-        self.openerp_id = #{param['id'] || false}
-        self.info = '#{(param['info'] || '').gsub("'",' ')}'
-        self.name = '#{param['name']}'
-        self.state = '#{param['state']}'
-        self.field_ids = #{(param['field_id'] and '[' + param['field_id'].join(',') + ']') || false}
-        self.access_ids = #{(param['access_ids'] and '[' + param['access_ids'].join(',') + ']') || false}
-        self.many2one_relations = {}
-        self.one2many_relations = {}
-        self.many2many_relations = {}
-      end"
-      eval definition, binding
-    end
-
-
     # ******************** remote communication ********************
 
     #OpenERP search method
@@ -78,12 +50,7 @@ class OpenObjectResource < ActiveResource::Base
 
     def client(url)
       @clients ||= {}
-      @client = @clients[url]
-      unless @clientl
-        @client ||= XMLRPC::Client.new2(url)
-        @clients[url] = @client
-      end
-      return @client
+      @clients[url] ||= XMLRPC::Client.new2(url)
     end
 
     #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
@@ -92,16 +59,16 @@ class OpenObjectResource < ActiveResource::Base
     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)
+      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)
       if args[-1].is_a? Hash
-        args[-1] = Ooor.global_context.merge(args[-1])
+        args[-1] = @ooor.global_context.merge(args[-1])
       end
       logger.debug "rpc_execute_with_all: rpc_methods: 'execute', db: #{db.inspect}, uid: #{uid.inspect}, pass: #{pass.inspect}, obj: #{obj.inspect}, method: #{method}, *args: #{args.inspect}"
-      try_with_pretty_error_log { client((@database && @site || Ooor.base_url) + "/object").call("execute",  db, uid, pass, obj, method, *args) }
+      try_with_pretty_error_log { 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)
@@ -110,23 +77,23 @@ class OpenObjectResource < ActiveResource::Base
     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)
+      rpc_exec_workflow_with_all(@database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], object, action, *args)
     end
 
     def rpc_exec_workflow_with_all(db, uid, pass, obj, action, *args)
       if args[-1].is_a? Hash
-        args[-1] = Ooor.global_context.merge(args[-1])
+        args[-1] = @ooor.global_context.merge(args[-1])
       end
       logger.debug "rpc_execute_with_all: rpc_methods: 'exec_workflow', db: #{db.inspect}, uid: #{uid.inspect}, pass: #{pass.inspect}, obj: #{obj.inspect}, action #{action}, *args: #{args.inspect}"
-      try_with_pretty_error_log { client((@database && @site || Ooor.base_url) + "/object").call("exec_workflow", db, uid, pass, obj, action, *args) }
+      try_with_pretty_error_log { client((@database && @site || @ooor.base_url) + "/object").call("exec_workflow", db, uid, pass, obj, action, *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)
+      context = @ooor.global_context.merge(context)
       unless wizard_id
-        wizard_id = try_with_pretty_error_log { 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) }
+        wizard_id = try_with_pretty_error_log { 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
-      [wizard_id, try_with_pretty_error_log { 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, {'model' => @openerp_model, 'form' => form, 'id' => ids[0], 'report_type' => report_type, 'ids' => ids}, step, context) }]
+      [wizard_id, try_with_pretty_error_log { 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, {'model' => @openerp_model, 'form' => form, 'id' => ids[0], 'report_type' => report_type, 'ids' => ids}, step, context) }]
     end
 
     #grab the eventual error log from OpenERP response as OpenERP doesn't enforce carefuly
@@ -146,17 +113,13 @@ class OpenObjectResource < ActiveResource::Base
         raise
     end
 
-    def method_missing(method_symbol, *arguments)
-      return self.rpc_execute(method_symbol.to_s, *arguments)
-    end
+    def method_missing(method_symbol, *arguments) return self.rpc_execute(method_symbol.to_s, *arguments) end
 
-    def load_relation(model_key, ids, *arguments)
+    def load_relation(model_key, ids, scope_prefix, *arguments)
       options = arguments.extract_options!
-      unless Ooor.all_loaded_models.index(model_key)
-        model = IrModel.find(:first, :domain => [['model', '=', model_key]])
-        define_openerp_model(model, nil, nil, nil, nil, Ooor.binding)
-      end
-      relation_model_class = eval class_name_from_model_key(model_key)
+      class_name = class_name_from_model_key(model_key)
+      @ooor.define_openerp_model(model_key, nil, nil, nil, nil, scope_prefix) unless Object.const_defined?(class_name)
+      relation_model_class = Object.const_get(class_name)
       relation_model_class.send :find, ids, :fields => options[:fields] || [], :context => options[:context] || {}
     end
 
@@ -180,9 +143,7 @@ class OpenObjectResource < ActiveResource::Base
     end
 
     #TODO, make sense?
-    def find_one
-      raise "Not implemented yet, go on!"
-    end
+    def find_one; raise"Not implemented yet, go on!"; end
 
     # Find a single resource from the default URL
     def find_single(scope, options)
@@ -216,28 +177,87 @@ class OpenObjectResource < ActiveResource::Base
 
   attr_accessor :relations, :loaded_relations
 
-  def pre_cast_attributes
-    @attributes.each {|k, v| @attributes[k] = ((v.is_a? BigDecimal) ? Float(v) : v)}
+  def cast_attributes_to_ruby!
+    @attributes.each do |k, v|
+      if self.class.fields[k]
+        if v.is_a?(String)
+          case self.class.fields[k].ttype
+            when 'datetime'
+              @attributes[k] = Time.parse(v)
+            when 'date'
+              @attributes[k] = Date.parse(v)
+          end
+        end
+      end
+    end
   end
 
-  def reload_from_record!(record)
-    load(record.attributes, record.relations)
+  def cast_attributes_to_openerp!
+    @attributes.each do |k, v|
+      @attributes[k] = ((v.is_a? BigDecimal) ? Float(v) : v)
+      if self.class.fields[k]
+        case self.class.fields[k].ttype
+          when 'datetime'
+            @attributes[k] = "#{v.year}-#{v.month}-#{v.day} #{v.hour}:#{v.min}:#{v.sec}" if v.respond_to?(:sec)
+          when 'date'
+            @attributes[k] = "#{v.year}-#{v.month}-#{v.day}" if v.is_a?(Date)
+        end
+      end
+    end
+  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))
+    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, {}]
+          end
+        end
+      elsif many2many_relations[k]
+        return v = [[6, 0, v]]
+      end
+    end
+
+    @relations.each do |k, v| #see OpenERP awkward relations API
+      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 na inherited o2m or m2m:
+          class_name = self.class.class_name_from_model_key(field.relation)
+          self.class.ooor.define_openerp_model(field.relation, nil, nil, nil, nil, self.class.scope_prefix) unless Object.const_defined?(class_name)
+          linked_class = Object.const_get(class_name)
+          linked_class.reload_fields_definition unless linked_class.fields_defined
+          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
+    end
   end
 
+  def reload_from_record!(record) load(record.attributes, record.relations) end
+
   def load(attributes, relations={})
-    self.class.reload_fields_definition unless self.class.field_defined
+    self.class.reload_fields_definition() unless self.class.fields_defined
     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.many2one_relations.has_key?(skey) || self.class.one2many_relations.has_key?(skey) || self.class.many2many_relations.has_key?(skey)
+      if self.class.many2one_relations.has_key?(skey) || self.class.one2many_relations.has_key?(skey) ||
+         self.class.many2many_relations.has_key?(skey) || value.is_a?(Array)
         relations[skey] = value #the relation because we want the method to load the association through method missing
       else
         case value
-          when self.class.many2one_relations.has_key?(skey) || self.class.one2many_relations.has_key?(skey) || self.class.many2many_relations.has_key?(skey)
-             relations[skey] = value #the relation because we want the method to load the association through method missing
           when Hash
             resource = find_or_create_resource_for(key) #TODO check!
             @attributes[skey] = resource@attributes[skey].new(value)
@@ -246,25 +266,40 @@ class OpenObjectResource < ActiveResource::Base
         end
       end
     end
-
+    cast_attributes_to_ruby!
     self
   end
 
-  #compatible with the Rails way but also supports OpenERP context; TODO: properly pass one2many and many2many object graph like GTK client
+  def display_available_fields
+    self.class.logger.debug ""
+    self.class.logger.debug "*** DIRECTLY AVAILABLE FIELDS ON OBJECT #{self} ARE: ***\n"
+    self.class.fields.sort {|a,b| a[1].ttype<=>b[1].ttype}.each {|i| self.class.logger.debug "#{i[1].ttype} --- #{i[0]}"}
+    self.class.logger.debug ""
+    self.class.many2one_relations.each {|k, v| self.class.logger.debug "many2one --- #{v.relation} --- #{k}"}
+    self.class.logger.debug ""
+    self.class.one2many_relations.each {|k, v| self.class.logger.debug "one2many --- #{v.relation} --- #{k}"}
+    self.class.logger.debug ""
+    self.class.many2many_relations.each {|k, v| self.class.logger.debug "many2many --- #{v.relation} --- #{k}"}
+    self.class.logger.debug ""
+    self.class.logger.debug "YOU CAN ALSO USE THE INHERITED FIELDS FROM THE INHERITANCE MANY2ONE RELATIONS OR THE OBJECT METHODS..."
+    self.class.logger.debug ""
+  end
+
+  def to_openerp_hash!
+    cast_attributes_to_openerp!
+    cast_relations_to_openerp!
+    @attributes.reject {|key, value| key == 'id'}.merge(@relations)
+  end
+
+  #compatible with the Rails way but also supports OpenERP context
   def create(context={})
-    self.pre_cast_attributes
-    m2o = @relations.reject{|k, v| !self.class.many2one_relations.has_key?(k)}
-    vals = @attributes.merge(m2o.merge(m2o){|k, v| v.is_a?(Array) ? v[0] : v})
-    self.id = self.class.rpc_execute('create', vals, context)
+    self.id = self.class.rpc_execute('create', to_openerp_hash!, context)
     reload_from_record!(self.class.find(self.id, :context => context))
   end
 
-  #compatible with the Rails way but also supports OpenERP context; TODO: properly pass one2many and many2many object graph like GTK client
+  #compatible with the Rails way but also supports OpenERP context
   def update(context={})
-    self.pre_cast_attributes
-    m2o = @relations.reject{|k, v| !self.class.many2one_relations.has_key?(k)}
-    vals = @attributes.reject {|key, value| key == 'id'}.merge(m2o.merge(m2o){|k, v| v.is_a?(Array) ? v[0] : v})
-    self.class.rpc_execute('write', self.id, vals, context)
+    self.class.rpc_execute('write', self.id, to_openerp_hash!, context)
     reload_from_record!(self.class.find(self.id, :context => context))
   end
 
@@ -274,21 +309,21 @@ class OpenObjectResource < ActiveResource::Base
   end
 
   #OpenERP copy method, load persisted copied Object
-  def copy(defaults=[], context={})
+  def copy(defaults={}, context={})
     self.class.find(self.class.rpc_execute('copy', self.id, defaults, context), :context => context)
   end
 
   #Generic OpenERP rpc method call
-  def call(method, *args)
-    self.class.rpc_execute(method, *args)
-  end
+  def call(method, *args) self.class.rpc_execute(method, *args) end
 
   #Generic OpenERP on_change method
-  def on_change(on_change_method, *args)
-    result = self.class.rpc_execute(on_change_method, *args)
-    self.classlogger.info result["warning"]["title"] if result["warning"]
-    self.class.logger.info result["warning"]["message"] if result["warning"]
-    load(result["value"])
+  def on_change(on_change_method, field_name, field_value, *args)
+    result = self.class.rpc_execute(on_change_method, self.id && [id] || [], *args)
+    if result["warning"]
+      self.class.logger.info result["warning"]["title"]
+      self.class.logger.info result["warning"]["message"]
+    end
+    load({field_name => field_value}.merge(result["value"]))
   end
 
   #wrapper for OpenERP exec_workflow Business Process Management engine
@@ -299,20 +334,20 @@ class OpenObjectResource < ActiveResource::Base
 
   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, {})
-    OpenObjectWizard.new(wizard_name, result[0], result[1], [self])
+    OpenObjectWizard.new(wizard_name, result[0], result[1], [self], self.class.ooor.global_context)
   end
 
 
   # ******************** fake associations like much like ActiveRecord according to the cached OpenERP data model ********************
 
   def relationnal_result(method_name, *arguments)
-    self.class.reload_fields_definition unless self.class.field_defined
+    self.class.reload_fields_definition unless self.class.fields_defined
     if self.class.many2one_relations.has_key?(method_name)
-      self.class.load_relation(self.class.many2one_relations[method_name].relation, @relations[method_name][0], *arguments)
+      self.class.load_relation(self.class.many2one_relations[method_name].relation, @relations[method_name][0], self.class.scope_prefix, *arguments)
     elsif self.class.one2many_relations.has_key?(method_name)
-      self.class.load_relation(self.class.one2many_relations[method_name].relation, @relations[method_name], *arguments)
+      self.class.load_relation(self.class.one2many_relations[method_name].relation, @relations[method_name], self.class.scope_prefix, *arguments)
     elsif self.class.many2many_relations.has_key?(method_name)
-      self.class.load_relation(self.class.many2many_relations[method_name].relation, @relations[method_name], *arguments)
+      self.class.load_relation(self.class.many2many_relations[method_name].relation, @relations[method_name], self.class.scope_prefix, *arguments)
     else
       false
     end
@@ -320,24 +355,33 @@ class OpenObjectResource < ActiveResource::Base
 
   def method_missing(method_symbol, *arguments)
     method_name = method_symbol.to_s
+    return super if attributes.has_key?(method_name) or attributes.has_key?(method_name.first(-1))
+    if method_name.end_with?('=')
+      @relations[method_name.sub('=', '')] = *arguments
+      return
+    end
     return @loaded_relations[method_name] if @loaded_relations.has_key?(method_name)
-    if @relations.has_key?(method_name) and !@relations[method_name]
-      return false
-    else
-      result = relationnal_result(method_name, *arguments)
-      if result
-        @loaded_relations[method_name] = result
-        return result
-      elsif @relations and @relations.has_key?(method_name) and !self.class.many2one_relations.empty?
-        #maybe the relation is inherited or could be inferred from a related field
-        self.class.many2one_relations.each do |k, field|
-          model = self.class.load_relation(field.relation, @relations[method_name][0], *arguments)
-          result = model.relationnal_result(method_name, *arguments)
-          return result if result
+    return false if @relations.has_key?(method_name) and !@relations[method_name]
+
+    result = relationnal_result(method_name, *arguments)
+    if result
+      @loaded_relations[method_name] = result
+      return result
+    elsif !self.class.many2one_relations.empty? #maybe the relation is inherited or could be inferred from a related field
+      self.class.many2one_relations.each do |k, field|
+        if @relations[k]
+          @loaded_relations[k] ||= self.class.load_relation(field.relation, @relations[k][0], self.class.scope_prefix, *arguments)
+          model = @loaded_relations[k]
+          model.loaded_relations[method_name] ||= model.relationnal_result(method_name, *arguments)
+          return model.loaded_relations[method_name] if model.loaded_relations[method_name]
         end
-        super
       end
+      super
     end
+
+  rescue
+    display_available_fields
+
     super
   end
 

data/lib/app/models/open_object_ui.rb

@@ -10,7 +10,7 @@ end
 class OpenObjectWizard < OpenObjectLayoutedFields
   attr_accessor :name, :id, :datas, :arch, :fields, :type, :state, :open_object_resources
 
-  def initialize(name, id, data, open_object_resources)
+  def initialize(name, id, data, open_object_resources, wizard_context)
     super(data['arch'], data['fields'])
     @name = name
     @id = id
@@ -18,16 +18,17 @@ class OpenObjectWizard < OpenObjectLayoutedFields
     @datas = data['datas'].symbolize_keys!
     @type = data['type']
     @state = data['state']
+    @wizard_context = wizard_context
   end
 
   def method_missing(method_symbol, *arguments)
     values = @datas.merge((arguments[0] || {}).symbolize_keys!)
-    context = Ooor.global_context.merge(arguments[1] || {})
+    context = @wizard_context.merge(arguments[1] || {})
     if @open_object_resources.size == 1
       open_object_resource = @open_object_resources[0]
       data = open_object_resource.class.old_wizard_step(@name, [open_object_resource.id], method_symbol, @id, values, context)
       if data[1]['state'] == 'end'
-        return open_object_resource.load(open_object_resource.class.find(open_object_resource.id, :context => context).attributes)
+        return open_object_resource.reload_from_record!(open_object_resource.class.find(open_object_resource.id, :context => context))
       end
       @arch = data[1]['arch']
       @fields = data[1]['fields']

data/lib/app/models/uml.rb

@@ -0,0 +1,180 @@
+require 'set'
+
+module UML
+  #usage: UML.print_uml or with options: UML.print_uml(:all, : detailed) or MyOpenObjectResource.print_uml or UML.print_uml([list_of_classes], :all, :detailed)
+
+  def self.included(base) base.extend(ClassMethods) end
+
+  def print_uml(*options)
+    UML.print_uml(@config[:models] && @all_loaded_models.select {|model| @config[:models].index(model.openerp_model)} || @all_loaded_models, options)
+  end
+
+  module ClassMethods
+    def print_uml(*options)
+      UML.print_uml([self], options) if self.is_a?(OpenObjectResource)
+    end
+  end
+
+  def self.display_fields(clazz)
+    s = ""
+    clazz.reload_fields_definition if clazz.fields.empty?
+    clazz.fields.sort {|a,b| a[1].ttype <=> b[1].ttype}.each {|i| s << "+ #{i[1].ttype} : #{i[0]}\\l\\n"}
+    s
+  end
+
+  def self.print_uml(classes, *options)
+    options = options[0] if options[0].is_a?(Array)
+    local = (options.index(:all) == nil)
+    detailed = (options.index(:detailed) != nil) || local && (options.index(:nodetail) == nil)
+
+    enabled_targets = classes[0].ooor.config[:models] #defines the scope of the UML for option local
+    m2o_edges = {}
+    o2m_edges = {}
+    m2m_edges = {}
+    #instead of diplaying several relations of the same kind between two nodes which would bloat the graph,
+    #we track them all and factor them on a common multiline edge label:
+    connex_classes = UML.collect_edges(false, local, classes, enabled_targets, m2o_edges, o2m_edges, m2m_edges)
+    #back links from connex classes:
+    connex_classes += UML.collect_edges(true, local, connex_classes - classes, classes, m2o_edges, o2m_edges, m2m_edges)
+
+    File.open('uml.dot', 'w') do |f|
+      f << <<-eos
+      digraph G {
+          fontname = "Bitstream Vera Sans"
+          fontsize = 8
+          label = "*** generated by OOOR by www.akretion.com ***"
+          node [
+                  fontname = "Bitstream Vera Sans"
+                  fontsize = 16
+                  shape = "record"
+                  fillcolor=orange
+                  style="rounded,filled"
+          ]
+          edge [
+                  arrowhead = "none"
+                  fontname = "Bitstream Vera Sans"
+                  fontsize = 9
+          ]
+      eos
+
+      #UML nodes definitions
+      ((connex_classes - classes) + classes - [IrModel, IrModelFields]).each do |model|
+        f << " #{model} [ label = \"{#{model.name}#{detailed ? '|' + display_fields(model) : ''}}\" ]"
+      end
+
+      #many2one:
+      f << <<-eos
+          edge [
+                headlabel = "1"
+                taillabel = "n"
+          ]
+          eos
+      m2o_edges.each do |k, v|
+        reverse_part = v[3].size > 0 ? "\\n/#{v[3].join("\\n")}\"]\n" : "\"]\n"
+        f << "edge [label = \"#{v[2].join("\\n")}#{reverse_part}"
+        f << "#{v[0]} -> #{v[1]}\n"
+      end
+
+      #one2many:
+      f << <<-eos
+          edge [
+                headlabel = "n"
+                taillabel = "1"
+          ]
+          eos
+      o2m_edges.each do |k, v|
+        f << "edge [label = \"#{v[3].join("\\n")}\"]\n"
+        f << "#{v[0]} -> #{v[1]}\n"
+      end
+
+      #many2many:
+      f << <<-eos
+          edge [
+                headlabel = "n"
+                taillabel = "n"
+          ]
+          eos
+      m2m_edges.each do |k, v|
+        reverse_part = v[3].size > 0 ? "\\n/#{v[3].join("\\n")}\"]\n" : "\"]\n"
+        f << "edge [label = \"#{v[2].join("\\n")}}#{reverse_part}"
+        f << "#{v[0]} -> #{v[1]}\n"
+      end
+
+      f << "}"
+    end
+
+    begin
+      cmd_line1 = "rm  uml.png"
+      system(cmd_line1)
+    rescue
+    end
+    cmd_line2 = "dot -Tpng uml.dot -o uml.png"
+    system(cmd_line2)
+  end
+
+  def self.collect_edges(is_reverse, local, classes, enabled_targets, m2o_edges, o2m_edges, m2m_edges)
+    connex_classes = Set.new
+
+    classes.each do |model|
+      model.reload_fields_definition if model.fields.empty?
+
+      #many2one:
+      model.many2one_relations.each do |k, field|
+        target = UML.get_target(is_reverse, local, enabled_targets, field, model)
+        if target
+          connex_classes.add(target)
+          if m2o_edges["#{model}-#{target}"]
+            m2o_edges["#{model}-#{target}"][2] += [k]
+          else
+            m2o_edges["#{model}-#{target}"] = [model, target, [k], []]
+          end
+        end
+
+      end
+    end
+
+   classes.each do |model|
+      #one2many:
+      model.one2many_relations.each do |k, field|
+        target = UML.get_target(is_reverse, local, enabled_targets, field, model)
+        if target
+          connex_classes.add(target)
+          if m2o_edges["#{target}-#{model}"]
+            m2o_edges["#{target}-#{model}"][3] += [k]
+          elsif o2m_edges["#{model}-#{target}"]
+            o2m_edges["#{model}-#{target}"][3] += [k]
+          else
+            o2m_edges["#{model}-#{target}"] = [model, target, [], [k]]
+          end
+        end
+      end
+
+      #many2many:
+      model.many2many_relations.each do |k, field|
+        target = UML.get_target(is_reverse, local, enabled_targets, field, model)
+        if target
+          connex_classes.add(target)
+          if m2m_edges["#{model}-#{target}"]
+            m2m_edges["#{model}-#{target}"][2] += [k]
+          elsif m2m_edges["#{target}-#{model}"]
+            m2m_edges["#{target}-#{model}"][3] += [k]
+          else
+            m2m_edges["#{model}-#{target}"] = [model, target, [k], []]
+          end
+        end
+      end
+
+    end
+    connex_classes
+  end
+
+  private
+
+  def self.get_target(is_reverse, local, enabled_targets, field, model)
+    if (is_reverse && !local) || (!enabled_targets) || enabled_targets.index(field.relation)
+      target_name = model.class_name_from_model_key(field.relation)
+      return Object.const_defined?(target_name) ? Object.const_get(target_name) : model.ooor.define_openerp_model(field.relation, nil, nil, nil, nil, model.scope_prefix)
+    end
+    return false
+  end
+end

data/lib/ooor.rb

@@ -1,89 +1,95 @@
 require 'logger'
 require 'xmlrpc/client'
+require 'app/models/open_object_resource'
+require 'app/models/uml'
+
+class Ooor
+  include UML
+
+  attr_accessor :logger, :config, :all_loaded_models, :base_url, :global_context, :ir_model_class
+
+  #load the custom configuration
+  def self.load_config(config_file=nil, env=nil)
+    config_file ||= defined?(RAILS_ROOT) && "#{RAILS_ROOT}/config/ooor.yml" || 'ooor.yml'
+    @config = YAML.load_file(config_file)[env || 'development']
+  rescue SystemCallError
+    @logger.error """failed to load OOOR yaml configuration file.
+       make sure your app has a #{config_file} file correctly set up
+       if not, just copy/paste the default ooor.yml file from the OOOR Gem
+       to #{RAILS_ROOT}/config/ooor.yml and customize it properly\n\n"""
+    raise
+  end
 
-module Ooor
-
-  class << self
-
-    attr_accessor :logger, :config, :all_loaded_models, :binding, :base_url, :global_context
-
-    #load the custom configuration
-    def load_config(config_file=nil, env=nil)
-      config_file ||= defined?(RAILS_ROOT) && "#{RAILS_ROOT}/config/ooor.yml" || 'ooor.yml'
-      env ||= defined?(RAILS_ENV) && RAILS_ENV || 'development'
-      Ooor.config = YAML.load_file(config_file)[env]
-    rescue SystemCallError
-      Ooor.logger.error """failed to load OOOR yaml configuration file.
-         make sure your app has a #{config_file} file correctly set up
-         if not, just copy/paste the default ooor.yml file from the OOOR Gem
-         to #{RAILS_ROOT}/config/ooor.yml and customize it properly\n\n"""
-      raise
-    end
-
-    def loaded?
-      Ooor.all_loaded_models.size > 0
+  def global_login(user, password)
+    begin
+    @config[:username] = user
+    @config[:password] = password
+    client = OpenObjectResource.client(@base_url + "/common")
+    OpenObjectResource.try_with_pretty_error_log { client.call("login", @config[:database], user, password)}
+    rescue SocketError => 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"}"""
     end
+  end
 
-    def global_login(user, password)
-      begin
-      Ooor.config[:username] = user
-      Ooor.config[:password] = password
-      client = OpenObjectResource.client(Ooor.base_url + "/common")
-      OpenObjectResource.try_with_pretty_error_log { client.call("login", Ooor.config[:database], user, password)}
-      rescue SocketError => error
-        Ooor.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 #{Ooor.config[:url].gsub(/\/$/,'') + "/common"}"""
-      end
+  def initialize(config, env=false)
+    @config = config.is_a?(String) ? Ooor.load_config(config, env) : config
+    @config.symbolize_keys!
+    @logger = ((defined?(RAILS_ENV) and RAILS_ENV != "development") ? Rails.logger : Logger.new(STDOUT))
+    @logger.level = config[:log_level] if config[:log_level]
+    @base_url = config[:url].gsub(/\/$/,'')
+    @global_context = config[:global_context] || {}
+    config[:user_id] = global_login(config[:username] || 'admin', config[:password] || 'admin')
+
+    @all_loaded_models = []
+    OpenObjectResource.logger = @logger
+    @ir_model_class = define_openerp_model("ir.model", nil, nil, nil, nil, config[:scope_prefix] || '')
+    define_openerp_model("ir.model.fields", nil, nil, nil, nil, config[:scope_prefix] || '')
+
+    if config[:models] #we load only a customized subset of the OpenERP models
+      models = @ir_model_class.find(:all, :domain => [['model', 'in', config[:models]]])
+    else #we load all the models
+      models = @ir_model_class.find(:all).reject {|model| model.model == "ir.model" || model.model == "ir.model.fields"}
     end
+    models.each {|openerp_model| define_openerp_model(openerp_model, nil, nil, nil, nil, config[:scope_prefix] || '')}
+  end
 
-    def reload!(config=false, env=false, keep_config=false)
-      Ooor.config = config.is_a?(Hash) && config or keep_config && Ooor.config or self.load_config(config, env)
-      Ooor.config.symbolize_keys!
-      Ooor.logger.level = Ooor.config[:log_level] if Ooor.config[:log_level]
-      Ooor.base_url = Ooor.config[:url].gsub(/\/$/,'')
-      Ooor.global_context = Ooor.config[:global_context] || {}
-      Ooor.config[:user_id] = global_login(Ooor.config[:username] || 'admin', Ooor.config[:password] || 'admin')
-
-      #*************** load the models
-
-      Ooor.all_loaded_models = []
-      OpenObjectResource.logger = Ooor.logger
-      OpenObjectResource.define_openerp_model("ir.model", nil, nil, nil, nil, Ooor.binding)
-      OpenObjectResource.define_openerp_model("ir.model.fields", nil, nil, nil, nil, Ooor.binding)
-
-      if Ooor.config[:models] #we load only a customized subset of the OpenERP models
-        models = IrModel.find(:all, :domain => [['model', 'in', Ooor.config[:models]]])
-      else #we load all the models
-        models = IrModel.find(:all)
-      end
-
-      models.each {|openerp_model| OpenObjectResource.define_openerp_model(openerp_model, nil, nil, nil, nil, Ooor.binding)}
-
-      # *************** load the models REST controllers
-      if defined?(ActionController)
-        OpenObjectsController.logger = Ooor.logger
-        models.each {|openerp_model| OpenObjectsController.define_openerp_controller(openerp_model.model, Ooor.binding) }
-      end
-
+  def define_openerp_model(arg, url, database, user_id, pass, scope_prefix)
+    if arg.is_a?(String) && arg != 'ir.model' && arg != 'ir.model.fields'
+      arg = @ir_model_class.find(:first, :domain => [['model', '=', arg]])
     end
-
+    param = (arg.is_a? OpenObjectResource) ? arg.attributes.merge(arg.relations) : {'model' => arg}
+    klass = Class.new(OpenObjectResource)
+    klass.ooor = self
+    klass.site = url || @base_url
+    klass.user = user_id
+    klass.password = pass
+    klass.openerp_database = database
+    klass.openerp_model = param['model']
+    klass.openerp_id = url || param['id']
+    klass.info = (param['info'] || '').gsub("'",' ')
+    klass.name = param['name']
+    klass.state = param['state']
+    klass.field_ids = param['field_id']
+    klass.access_ids = param['access_ids']
+    klass.many2one_relations = {}
+    klass.one2many_relations = {}
+    klass.many2many_relations = {}
+    klass.fields = {}
+    klass.scope_prefix = scope_prefix
+    model_class_name = klass.class_name_from_model_key
+    @logger.info "registering #{model_class_name} as a Rails ActiveResource Model wrapper for OpenObject #{param['model']} model"
+    Object.const_set(model_class_name, klass)
+    @all_loaded_models.push(klass)
+    klass
   end
 
 end
 
-
-Ooor.logger = ((defined?(RAILS_ENV) and RAILS_ENV != "development") ? Rails.logger : Logger.new(STDOUT))
-Ooor.binding = lambda {}
-
-require 'app/models/open_object_resource'
-require 'app/controllers/open_objects_controller'
-
-
+#Optionnal Rails settings:
 if defined?(Rails)
-  include Ooor
-  if Ooor.load_config['bootstrap']
-    Ooor.reload!(false, false, true)
-  end
+  config = Ooor.load_config(false, RAILS_ENV)
+  OOOR = Ooor.new(config) if config['bootstrap']
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ooor
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
   - Raphael Valyi - www.akretion.com
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-16 00:00:00 -02:00
+date: 2010-01-18 00:00:00 -02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -36,7 +36,7 @@ files:
   - lib/ooor.rb
   - lib/app/models/open_object_resource.rb
   - lib/app/models/open_object_ui.rb
-  - lib/app/controllers/open_objects_controller.rb
+  - lib/app/models/uml.rb
   - ooor.yml
 has_rdoc: true
 homepage: http://github.com/rvalyi/ooor

data/lib/app/controllers/open_objects_controller.rb

@@ -1,139 +0,0 @@
-require 'action_controller'
-
-class OpenObjectsController < ActionController::Base
-
-  #TODO get lang from URL in before filter
-  #TODO use timezone from HTTP header and put is in context
-
-  # ******************** class methods ********************
-  class << self
-
-    cattr_accessor :logger
-
-    def model_class
-        if defined?(@model_class)
-          @model_class
-        elsif superclass != Object && superclass.model_class
-          superclass.model_class.dup.freeze
-        end
-    end
-
-    def model_class=(_model_class)
-      @model_class = _model_class
-    end
-
-    def ids_from_param(param)
-      if param.split(',').size > 0
-        return eval param
-      else
-        return param
-      end
-    end
-
-    def define_openerp_controller(model_key, binding)
-      model_class_name = OpenObjectResource.class_name_from_model_key(model_key)
-      controller_class_name = model_class_name + "Controller"
-      logger.info "registering #{controller_class_name} as a Rails ActiveResource Controller wrapper for OpenObject #{model_key} model"
-      eval "
-      class #{controller_class_name} < OpenObjectsController
-        self.model_class = #{model_class_name}
-      end
-      ", binding
-    end
-
-    def load_all_controllers(map)
-      Ooor.all_loaded_models.each do |model|
-        map.resources model.gsub('.', '_').to_sym
-      end
-    end
-
-  end
-
-
-  # ******************** instance methods ********************
-
-  # GET /models
-  # GET /models.xml
-  def index
-    @models = self.class.model_class.find(:all)
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml => @models }
-    end
-  end
-
-  # GET /models/1
-  # GET /models/1.xml
-  def show
-    @models = self.class.model_class.find(self.class.ids_from_param(params[:id]))
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml => @models }
-      format.json  { render :json => @models }
-    end
-  end
-
-  # GET /models/new
-  # GET /models/new.xml
-  def new
-    @models = self.class.model_class.new
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.xml  { render :xml => @models }
-    end
-  end
-
-  # GET /models/1/edit
-  def edit
-    @models = self.class.model_class.find(params[:id])
-  end
-
-  # POST /models
-  # POST /models.xml
-  def create
-    @models = self.class.model_class.new(params[:partners])
-
-    respond_to do |format|
-      if @models.save
-        flash[:notice] = 'Model was successfully created.'
-        format.html { redirect_to(@models) }
-        format.xml  { render :xml => @models, :status => :created, :location => @models }
-      else
-        format.html { render :action => "new" }
-        format.xml  { render :xml => @models.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # PUT /models/1
-  # PUT /models/1.xml
-  def update
-    @models = self.class.model_class.find(params[:id])
-
-    respond_to do |format|
-      if @models.update_attributes(params[:partners])
-        flash[:notice] = 'Partners was successfully updated.'
-        format.html { redirect_to(@models) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action => "edit" }
-        format.xml  { render :xml => @models.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # DELETE /models/1
-  # DELETE /models/1.xml
-  def destroy
-    @models = self.class.model_class.find(params[:id])
-    @models.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(url_for(:action => index)) }
-      format.xml  { head :ok }
-    end
-  end
-end