ooor 1.3.2 → 1.4.0

data/lib/app/models/base64.rb

@@ -0,0 +1,31 @@
+#    OOOR: Open Object On Rails
+#    Copyright (C) 2009-2010 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 'base64'
+module Base64
+  def serialize_binary_from_file(binary_path)
+		return Base64.encode64(File.read(binary_path))
+	end
+
+	def serialize_binary_from_content(content)
+		return Base64.encode64(content)
+	end
+
+	def unserialize_binary(content)
+		return Base64.decode64(content)
+	end
+end

data/lib/app/models/common_service.rb

@@ -1,3 +1,20 @@
+#    OOOR: Open Object On Rails
+#    Copyright (C) 2009-2010 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/>.
+
 #proxies all 'common' class of OpenERP server/bin/service/web_service.py properly
 module CommonService
   def global_login(user, password)

data/lib/app/models/db_service.rb

@@ -1,9 +1,27 @@
+#    OOOR: Open Object On Rails
+#    Copyright (C) 2009-2010 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/>.
+
 #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')
+  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] = user_password
+    @config[:username] = 'admin'
+    @config[:passowrd] = user_password
     while get_progress('admin', process_id) == [0, []]
       @logger.info "..."
       sleep(0.5)

data/lib/app/models/open_object_resource.rb

@@ -1,11 +1,25 @@
+#    OOOR: Open Object On Rails
+#    Copyright (C) 2009-2010 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'
 require 'rubygems'
 require 'active_resource'
 require 'app/ui/form_model'
 require 'app/models/uml'
-require 'set'
-
-#TODO implement passing session credentials to RPC methods (concurrent access of different user credentials in Rails)
 
 class OpenObjectResource < ActiveResource::Base
   include UML
@@ -25,27 +39,31 @@ class OpenObjectResource < ActiveResource::Base
     #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_key, self.scope_prefix)
+      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 unless klass.fields_defined
       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 reload_fields_definition(force = false)
-      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 = (self.scope_prefix ? Object.const_get(self.scope_prefix) : Object).const_get('IrModelFields').find(@field_ids)
+      if force or not @fields_defined
+        @fields_defined = true
         @fields = {}
-        fields.each do |field|
-          case field.attributes['ttype']
+        rpc_execute("fields_get").each do |k, field|
+          case field['type']
           when 'many2one'
-            @many2one_relations[field.attributes['name']] = field
+            @many2one_relations[k] = field
           when 'one2many'
-            @one2many_relations[field.attributes['name']] = field
+            @one2many_relations[k] = field
           when 'many2many'
-            @many2many_relations[field.attributes['name']] = field
+            @many2many_relations[k] = field
           when 'reference'
-            @polymorphic_m2o_relations[field.attributes['name']] = field
+            @polymorphic_m2o_relations[k] = field
           else
-            @fields[field.attributes['name']] = field
+            @fields[k] = field
           end
         end
         @relations_keys = @many2one_relations.keys + @one2many_relations.keys + @many2many_relations.keys + @polymorphic_m2o_relations.keys
@@ -60,7 +78,6 @@ class OpenObjectResource < ActiveResource::Base
         end
         logger.info "#{fields.size} fields loaded in model #{self.class}"
       end
-      @fields_defined = true
     end
 
     # ******************** remote communication ********************
@@ -72,7 +89,7 @@ class OpenObjectResource < ActiveResource::Base
 
     def client(url)
       @clients ||= {}
-      @clients[url] ||= XMLRPC::Client.new2(url, nil, 180)
+      @clients[url] ||= XMLRPC::Client.new2(url, nil, 900)
     end
 
     #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
@@ -163,7 +180,7 @@ class OpenObjectResource < ActiveResource::Base
       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].ttype
+            case self.fields[k]['type']
               when 'datetime'
                 map[k] = Time.parse(v)
               when 'date'
@@ -231,7 +248,7 @@ class OpenObjectResource < ActiveResource::Base
         record.each_pair do |k,v|
           r[k.to_sym] = v
         end
-        active_resources << instantiate_record(r, prefix_options)
+        active_resources << instantiate_record(r, prefix_options, context)
       end
       unless is_collection
         return active_resources[0]
@@ -240,8 +257,8 @@ class OpenObjectResource < ActiveResource::Base
     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 = {})
-      new(record, [], {}).tap do |resource|
+    def instantiate_record(record, prefix_options = {}, context = {})
+      new(record, [], context).tap do |resource|
         resource.prefix_options = prefix_options
       end
     end
@@ -251,7 +268,21 @@ class OpenObjectResource < ActiveResource::Base
 
   # ******************** instance methods ********************
 
-  attr_accessor :relations, :loaded_relations, :ir_model_data_id
+  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 cast_relations_to_openerp!
     @relations.reject! do |k, v| #reject non asigned many2one or empty list
@@ -282,7 +313,7 @@ class OpenObjectResource < ActiveResource::Base
         @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)
+          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
@@ -323,13 +354,12 @@ class OpenObjectResource < ActiveResource::Base
   end
 
   def display_available_fields
-    msg = "\n*** DIRECTLY AVAILABLE FIELDS ON OBJECT #{self} ARE: ***"
-    msg << "\n\n" << self.class.fields.sort {|a,b| a[1].ttype<=>b[1].ttype}.map {|i| "#{i[1].ttype} --- #{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")
-    msg << "\n\nYOU CAN ALSO USE THE INHERITED FIELDS FROM THE INHERITANCE MANY2ONE RELATIONS OR THE OBJECT METHODS...\n\n"
+    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
 
@@ -339,49 +369,55 @@ class OpenObjectResource < ActiveResource::Base
   end
 
   #takes care of reading OpenERP default field values.
-  #FIXME: until OpenObject explicits inheritances, we load all default values of all related fields, unless specified in default_get_list
   def initialize(attributes = {}, default_get_list=false, context={})
-    @attributes     = {}
+    @attributes = {}
     @prefix_options = {}
     @ir_model_data_id = attributes.delete(:ir_model_data_id)
-    if ['ir.model', 'ir.model.fields'].index(self.class.openerp_model) || default_get_list == []
+    @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() unless self.class.fields_defined
-      default_get_list ||= Set.new(self.class.many2one_relations.reject {|k, v| attributes.keys.index(k.to_sym)}.collect {|k, field| self.class.const_get(field.relation).fields.keys}.flatten + self.class.fields.keys).to_a
-      load(self.class.rpc_execute("default_get", default_get_list, context).symbolize_keys!.merge(attributes.symbolize_keys!))
+      load(rpc_execute("default_get", rpc_execute("fields_get").keys, @object_session[:context]).symbolize_keys!.merge(attributes.symbolize_keys!))
     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 = self.class.rpc_execute('create', to_openerp_hash!, context)
+    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)
-    self.class.rpc_execute('write', self.id, to_openerp_hash!, context)
+    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={})
-    self.class.rpc_execute('unlink', [self.id], context)
+    rpc_execute('unlink', [self.id], context)
   end
 
   #OpenERP copy method, load persisted copied Object
   def copy(defaults={}, context={})
-    self.class.find(self.class.rpc_execute('copy', self.id, defaults, context), :context => context)
+    self.class.find(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) 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(on_change_method, self.id && [id] || [], *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"]
@@ -390,9 +426,9 @@ class OpenObjectResource < ActiveResource::Base
   end
 
   #wrapper for OpenERP exec_workflow Business Process Management engine
-  def wkf_action(action, context={})
-    self.class.rpc_exec_workflow(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))
+  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 old_wizard_step(wizard_name, step='init', wizard_id=nil, form={}, context={})
@@ -408,11 +444,11 @@ class OpenObjectResource < ActiveResource::Base
   def relationnal_result(method_name, *arguments)
     self.class.reload_fields_definition unless self.class.fields_defined
     if self.class.many2one_relations.has_key?(method_name)
-      load_relation(self.class.many2one_relations[method_name].relation, @relations[method_name][0], *arguments)
+      load_relation(self.class.many2one_relations[method_name]['relation'], @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)
+      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)
+      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)
@@ -426,18 +462,18 @@ class OpenObjectResource < ActiveResource::Base
     is_assign = method_name.end_with?('=')
     method_key = method_name.sub('=', '')
     return super if attributes.has_key?(method_key)
-    return self.class.rpc_execute(method_name, *arguments) unless arguments.empty? || is_assign
+    return rpc_execute(method_name, *arguments) unless arguments.empty? || is_assign
 
     self.class.reload_fields_definition() unless self.class.fields_defined
 
     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
+      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
       end
-      know_fields = self.class.fields.keys + self.class.many2one_relations.collect {|k, field| self.class.const_get(field.relation).fields.keys}.flatten
+      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
 
@@ -450,27 +486,9 @@ class OpenObjectResource < ActiveResource::Base
     result = relationnal_result(method_name, *arguments)
     @loaded_relations[method_name] = result and return result if result
 
-    #maybe the relation is inherited or could be inferred from a related field
-    self.class.many2one_relations.each do |k, field| #TODO could be recursive eventually
-      if @relations[k] #we only care if instance has a relation
-        related_model = self.class.const_get(field.relation)
-        related_model.reload_fields_definition() unless related_model.fields_defined
-        if related_model.relations_keys.index(method_key)
-          @loaded_relations[k] ||= load_relation(field.relation, @relations[k][0], *arguments)
-          model = @loaded_relations[k]
-          model.loaded_relations[method_key] ||= model.relationnal_result(method_key, *arguments)
-          return model.loaded_relations[method_key] if model.loaded_relations[method_key]
-        end
-      elsif is_assign
-        klazz = self.class.const_get(field.relation)
-        @relations[method_key] = arguments[0] and return if klazz.relations_keys.index(method_key)
-        @attributes[method_key] = arguments[0] and return if klazz.fields.keys.index(method_key)
-      end
-    end
-
     if id
       arguments += [{}] unless arguments.last.is_a?(Hash)
-      self.class.rpc_execute(method_key, [id], *arguments) #we assume that's an action
+      rpc_execute(method_key, [id], *arguments) #we assume that's an action
     else
       super
     end

data/lib/app/models/uml.rb

@@ -1,3 +1,20 @@
+#    OOOR: Open Object On Rails
+#    Copyright (C) 2009-2010 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/>.
+
 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)
 
@@ -17,7 +34,7 @@ module UML
   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"}
+    clazz.fields.sort {|a,b| a[1]['type'] <=> b[1]['type']}.each {|i| s << "+ #{i[1]['type']} : #{i[0]}\\l\\n"}
     s
   end
 
@@ -170,8 +187,8 @@ module UML
   private
 
   def self.get_target(is_reverse, local, enabled_targets, field, model)
-    if (is_reverse && !local) || (!enabled_targets) || enabled_targets.index(field.relation)
-      model.const_get(field.relation)
+    if (is_reverse && !local) || (!enabled_targets) || enabled_targets.index(field['relation'])
+      model.const_get(field['relation'])
     else
       false
     end

data/lib/app/ui/action_window.rb

@@ -1,3 +1,20 @@
+#    OOOR: Open Object On Rails
+#    Copyright (C) 2009-2010 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/>.
+
 module ActionWindowModule
   def open(mode='tree', ids=nil)
     if view_mode.index(mode)