ooor 1.4.2 → 1.5.0

data/lib/app/ui/action_window.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
@@ -14,15 +14,89 @@
 #
 #    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 Ooor
+  class ActionWindow
+    class << self
+      attr_accessor :klass, :openerp_act_window, :views
+      
+      def from_menu(menu)
+        act_win_class = Class.new(ActionWindow)
+        act_win_class.openerp_act_window = menu.action
+        act_win_class.klass = menu.class.const_get(menu.action.res_model)
+        act_win_class.views = {}
+        act_win_class
+      end
+
+      def from_act_window(act_window)
+        act_win_class = Class.new(ActionWindow)
+        act_win_class.openerp_act_window = act_window
+        act_win_class.klass = act_window.class.const_get(act_window.res_model)
+        act_win_class.views = {}
+        act_win_class
+      end
+      
+      def from_model(act_window_param)
+        act_win_class = Class.new(ActionWindow)
+        act_win_class.openerp_act_window = IrActionsAct_window.find(:first, :domain=>[['res_model', '=', act_window_param.openerp_model]])
+        act_win_class.klass = act_window_param
+        act_win_class.views = {}
+        act_win_class
+      end 
+    
+      def get_view_id(mode)
+        IrActionsAct_window.read(@openerp_act_window.id, ["view_ids"])["view_ids"]
+        IrActionsAct_windowView.read([9,10], ["view_mode"]).each do |view_hash|
+          return view_hash["id"] if view_hash["view_mode"] == mode.to_s
+        end
+        IrUiView.search([['model', '=', act_window_param.openerp_model], ['type', '=', mode.to_s]])
+      end
+
+      def get_fields(mode)
+        @views[mode] ||= @klass.fields_view_get(get_view_id(mode), mode)
+        @views[mode]['fields'] #TODO order by occurrence in view XML
+      end
+
+      def column_names
+        reload_fields_definition
+        @column_names ||= ["id"] + get_fields('tree').keys()
+      end
+
+      def columns_hash
+        reload_fields_definition
+        unless @column_hash
+          @column_hash = {"id" => {"string"=>"Id", "type"=>"integer"}}.merge(get_fields('tree'))
+          def @column_hash.type
+            col_type = @column_hash['type'].to_sym #TODO mapping ?
+            col_type == :char && :string || col_type
+          end
+        end
+        @column_hash
+      end
+
+      def primary_key
+        "id"
+      end
+
+      def get_arch(mode)
+        #TODO
+      end
+
+      def open(mode='tree', ids=nil)#TODO: fix!
+        if view_mode.index(mode)
+          the_view_id = false
+          relations['views'].each do |tuple|
+            the_view_id = tuple[0] if tuple[1] == mode
+          end
+          self.class.ooor.build_object_view(self.class.ooor.const_get(res_model), the_view_id, mode, domain || [], ids, {})
+        end
+      end
 
-module ActionWindowModule
-  def open(mode='tree', ids=nil)
-    if view_mode.index(mode)
-      the_view_id = false
-      relations['views'].each do |tuple|
-        the_view_id = tuple[0] if tuple[1] == mode
+      def method_missing(method, *args, &block)
+        @klass.send(method, *args, &block)
       end
-      self.class.ooor.build_object_view(self.class.ooor.const_get(res_model), the_view_id, mode, domain || [], ids, {})
+    
     end
+    
+    
   end
 end

data/lib/app/ui/client_base.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
@@ -19,38 +19,35 @@ require 'app/ui/form_model'
 require 'app/ui/menu'
 require 'app/ui/action_window'
 
-module ClientBase
+module Ooor
+  module ClientBase
 
-  def menu_class
-    action_window_class()
-    const_get('ir.ui.menu').send :include, MenuModule
-  end
-
-  def action_window_class
-    const_get('ir.actions.act_window').send :include, ActionWindowModule
-  end
-
-  def get_init_menu(user_id=@config[:user_id])
-    const_get('res.users').read([user_id], ['menu_id', 'name'], @global_context)
-  end
+    def menu_class
+      const_get('ir.ui.menu').send :include, MenuModule
+    end
 
-  #Ooor can have wizards that are not object related, for instance to configure the initial database:
-  def old_wizard_step(wizard_name, step='init', wizard_id=nil, form={}, context={})
-    result = @ir_model_class.old_wizard_step(wizard_name, nil, step, wizard_id, form, {})
-    FormModel.new(wizard_name, result[0], nil, nil, result[1], [self], @global_context)#TODO set arch and fields
-  end
+    def get_init_menu(user_id=@config[:user_id])
+      const_get('res.users').read([user_id], ['menu_id', 'name'], @global_context)
+    end
 
-  def build_object_view(model_class, view_id, view_mode='form', domain=[], ids=nil, context={}, toolbar=false)
-    #TODO put in cache eventually:
-    view = model_class.fields_view_get(view_id, view_mode, @global_context, toolbar)
-    context = @global_context.merge(context)
-    ids = const_get(view['model']).search(domain) unless ids #TODO replace by search_read once OpenERP has that
-    values = const_get(view['model']).read(ids, view['fields'], context)
-    models = []
-    ids.each_with_index do |id, k|
-      models << const_get(view['model']).new(values[k], [], context)
+    #Ooor can have wizards that are not object related, for instance to configure the initial database:
+    def old_wizard_step(wizard_name, step='init', wizard_id=nil, form={}, context={})
+      result = @ir_model_class.old_wizard_step(wizard_name, nil, step, wizard_id, form, {})
+      FormModel.new(wizard_name, result[0], nil, nil, result[1], [self], @global_context)#TODO set arch and fields
     end
 
-    FormModel.new(view['name'], view['view_id'], view['arch'], view['fields'], nil, models, context, view['view_id'])
+    def build_object_view(model_class, view_id, view_mode='form', domain=[], ids=nil, context={}, toolbar=false)
+      #TODO put in cache eventually:
+      view = model_class.fields_view_get(view_id, view_mode, @global_context, toolbar)
+      context = @global_context.merge(context)
+      ids = const_get(view['model']).search(domain) unless ids #TODO replace by search_read once OpenERP has that
+      values = const_get(view['model']).read(ids, view['fields'], context)
+      models = []
+      ids.each_with_index do |id, k|
+        models << const_get(view['model']).new(values[k], [], context)
+      end
+
+      FormModel.new(view['name'], view['view_id'], view['arch'], view['fields'], nil, models, context, view['view_id'])
+    end
   end
 end

data/lib/app/ui/form_model.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
@@ -14,85 +14,86 @@
 #
 #    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 Ooor
+  class FormModel
+    attr_accessor :name, :wizard_id, :datas, :arch, :fields, :type, :state, :view_id, :open_object_resources, :view_context
 
-class FormModel
-  attr_accessor :name, :wizard_id, :datas, :arch, :fields, :type, :state, :view_id, :open_object_resources, :view_context
-
-  def initialize(name, wizard_id, arch, fields, data, open_object_resources, view_context, view_id=nil)
-    @arch = arch
-    @fields = fields
-    @name = name
-    @wizard_id = wizard_id
-    @open_object_resources = open_object_resources
-    @view_context = view_context
-    if data #it's a wizard
-      @datas = data['datas'].symbolize_keys!
-      @type = data['type']
-      update_wizard_state(data['state'])
+    def initialize(name, wizard_id, arch, fields, data, open_object_resources, view_context, view_id=nil)
+      @arch = arch
+      @fields = fields
+      @name = name
+      @wizard_id = wizard_id
+      @open_object_resources = open_object_resources
+      @view_context = view_context
+      if data #it's a wizard
+        @datas = data['datas'].symbolize_keys!
+        @type = data['type']
+        update_wizard_state(data['state'])
+      end
     end
-  end
 
-  def to_html
-    "<div>not implemented in OOOR core gem!</div>"
-  end
+    def to_html
+      "<div>not implemented in OOOR core gem!</div>"
+    end
 
-  def to_s
-    content = ""
-    content << @name
-    @open_object_resources.each do |resource|
-      content << "\n---------"
-      @fields.each do |k, v| #TODO no need for new call if many2one
-        if v['type'] == 'many2one'
-          content << "\n#{k}: #{resource.relations[k]}"
-        else
-          content << "\n#{k}: #{resource.send(k)}"
+    def to_s
+      content = ""
+      content << @name
+      @open_object_resources.each do |resource|
+        content << "\n---------"
+        @fields.each do |k, v| #TODO no need for new call if many2one
+          if v['type'] == 'many2one'
+            content << "\n#{k}: #{resource.relations[k]}"
+          else
+            content << "\n#{k}: #{resource.send(k)}"
+          end
         end
       end
     end
-  end
 
-  def old_wizard_step(method_symbol, *arguments)
-    values = @datas.merge!((arguments[0] || {}).symbolize_keys!)
-    context = @view_context.merge(arguments[1] || {})
-    if @open_object_resources.size == 1
-      open_object_resource = @open_object_resources[0]
-      if open_object_resource.is_a? Ooor
-        data = open_object_resource.ir_model_class.old_wizard_step(@name, nil, method_symbol, @wizard_id, values, context)
-      else
-        data = open_object_resource.class.old_wizard_step(@name, [open_object_resource.id], method_symbol, @wizard_id, values, context)
-      end
-      if data[1]['state'] == 'end'
+    def old_wizard_step(method_symbol, *arguments)
+      values = @datas.merge!((arguments[0] || {}).symbolize_keys!)
+      context = @view_context.merge(arguments[1] || {})
+      if @open_object_resources.size == 1
+        open_object_resource = @open_object_resources[0]
         if open_object_resource.is_a? Ooor
-          return 'end'
+          data = open_object_resource.ir_model_class.old_wizard_step(@name, nil, method_symbol, @wizard_id, values, context)
         else
-          return open_object_resource.reload_from_record!(open_object_resource.class.find(open_object_resource.id, :context => context))
+          data = open_object_resource.class.old_wizard_step(@name, [open_object_resource.id], method_symbol, @wizard_id, values, context)
+        end
+        if data[1]['state'] == 'end'
+          if open_object_resource.is_a? Ooor
+            return 'end'
+          else
+            return open_object_resource.reload_from_record!(open_object_resource.class.find(open_object_resource.id, :context => context))
+          end
         end
+        @arch = data[1]['arch']
+        @fields = data[1]['fields']
+        @datas.merge!(data[1]['datas'].symbolize_keys!) unless data[1]['datas'].empty?
+        @type = data[1]['type']
+        update_wizard_state(data[1]['state']) #FIXME ideally we should remove old methods
+        return self
+      else
+        ids = @open_object_resources.collect{ |open_object_resources| open_object_resources.id }
+        return open_object_resource.class.old_wizard_step(@name, ids, method_symbol, @wizard_id, values, context)
       end
-      @arch = data[1]['arch']
-      @fields = data[1]['fields']
-      @datas.merge!(data[1]['datas'].symbolize_keys!) unless data[1]['datas'].empty?
-      @type = data[1]['type']
-      update_wizard_state(data[1]['state']) #FIXME ideally we should remove old methods
-      return self
-    else
-      ids = @open_object_resources.collect{ |open_object_resources| open_object_resources.id }
-      return open_object_resource.class.old_wizard_step(@name, ids, method_symbol, @wizard_id, values, context)
     end
-  end
 
-  private
+    private
 
-  def update_wizard_state(state)
-    if state.is_a? Array
-      @state = state
-      @state.each do |state_item| #generates autocompletion handles
-        self.class_eval do
-          define_method state_item[0] do |*args|
-            self.send :old_wizard_step, *[state_item[0], *args]
+    def update_wizard_state(state)
+      if state.is_a? Array
+        @state = state
+        @state.each do |state_item| #generates autocompletion handles
+          self.class_eval do
+            define_method state_item[0] do |*args|
+              self.send :old_wizard_step, *[state_item[0], *args]
+            end
           end
         end
       end
     end
-  end
 
+  end
 end

data/lib/app/ui/menu.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,18 +16,19 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 require 'app/ui/action_window'
+module Ooor
+  module MenuModule
 
-module MenuModule
+    attr_accessor :menu_action
 
-  attr_accessor :menu_action
+    def menu_action
+      #TODO put in cache eventually:
+      action_values = self.class.ooor.const_get('ir.values').rpc_execute('get', 'action', 'tree_but_open', [['ir.ui.menu', id]], false, self.class.ooor.global_context)[0][2]#get already exists
+      @menu_action = self.class.ooor.const_get('ir.actions.act_window').new(action_values, []) #TODO deal with action reference instead
+    end
 
-  def menu_action
-    #TODO put in cache eventually:
-    action_values = self.class.ooor.const_get('ir.values').rpc_execute('get', 'action', 'tree_but_open', [['ir.ui.menu', id]], false, self.class.ooor.global_context)[0][2]#get already exists
-    @menu_action = self.class.ooor.const_get('ir.actions.act_window').new(action_values, []) #TODO deal with action reference instead
-  end
-
-  def open(mode='tree', ids=nil)
-    menu_action.open(mode, ids)
+    def open(mode='tree', ids=nil)
+      menu_action.open(mode, ids)
+    end
   end
 end

data/lib/ooor.rb

@@ -23,90 +23,103 @@ require 'app/models/common_service'
 require 'app/models/base64'
 require 'app/ui/client_base'
 
-class Ooor
-  include UML
-  include DbService
-  include CommonService
-  include ClientBase
+module Ooor
+  def self.new(*args)
+    Ooor.send :new, *args
+  end
+  
+  class Ooor
+    include UML
+    include DbService
+    include CommonService
+    include ClientBase
 
-  cattr_accessor :default_ooor, :default_config
-  attr_accessor :logger, :config, :loaded_models, :base_url, :global_context, :ir_model_class
+    cattr_accessor :default_ooor, :default_config
+    attr_accessor :logger, :config, :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
+    #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
+      puts """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"""
+      {}
+    end
 
-  def initialize(config, env=false)
-    @config = config.is_a?(String) ? Ooor.load_config(config, env) : config
-    @config.symbolize_keys!
-    @logger = ((defined?(Rails) && $0 != 'irb' || config[:force_rails_logger]) ? Rails.logger : Logger.new($stdout))
-    @logger.level = config[:log_level] if config[:log_level]
-    OpenObjectResource.logger = @logger
-    @base_url = config[:url].gsub(/\/$/,'')
-    @loaded_models = []
-    scope = Module.new and Object.const_set(config[:scope_prefix], scope) if config[:scope_prefix]
-    if config[:database]
-      load_models()
+    def initialize(config, env=false)
+      @config = config.is_a?(String) ? Ooor.load_config(config, env) : config
+      @config.symbolize_keys!
+      @logger = ((defined?(Rails) && $0 != 'irb' && Rails.logger || config[:force_rails_logger]) ? Rails.logger : Logger.new($stdout))
+      @logger.level = config[:log_level] if config[:log_level]
+      OpenObjectResource.logger = @logger
+      @base_url = config[:url].gsub(/\/$/,'')
+      @loaded_models = []
+      scope = Module.new and Object.const_set(config[:scope_prefix], scope) if config[:scope_prefix]
+      load_models() if config[:database]
     end
-  end
 
-  def const_get(model_key)
-    @ir_model_class.const_get(model_key)
-  end
+    def const_get(model_key)
+      @ir_model_class.const_get(model_key)
+    end
 
-  def load_models(to_load_models=@config[:models])
-    @global_context = @config[:global_context] || {}
-    global_login(@config[:username] || 'admin', @config[:password] || 'admin')
-    @ir_model_class = define_openerp_model({'model' => 'ir.model'}, @config[:scope_prefix])
-    if to_load_models #we load only a customized subset of the OpenERP models
-      model_ids = @ir_model_class.search([['model', 'in', to_load_models]])
-    else #we load all the models
-      model_ids = @ir_model_class.search() - [1, 2]
+    def load_models(to_load_models=@config[:models])
+      @global_context = @config[:global_context] || {}
+      global_login(@config[:username] || 'admin', @config[:password] || 'admin')
+      @ir_model_class = define_openerp_model({'model' => 'ir.model'}, @config[:scope_prefix])
+      if to_load_models #we load only a customized subset of the OpenERP models
+        model_ids = @ir_model_class.search([['model', 'in', to_load_models]])
+      else #we load all the models
+        model_ids = @ir_model_class.search() - [1]
+      end
+      models = @ir_model_class.read(model_ids, ['name', 'model', 'id', 'info', 'state'])#, 'field_id', 'access_ids'])
+      @global_context.merge!({}).merge!(@config[:global_context] || {})
+      models.each {|openerp_model| define_openerp_model(openerp_model, @config[:scope_prefix])}
     end
-    models = @ir_model_class.read(model_ids, ['name', 'model', 'id', 'info', 'state', 'field_id', 'access_ids'])
-    @global_context.merge!({}).merge!(@config[:global_context] || {})
-    models.each {|openerp_model| define_openerp_model(openerp_model, @config[:scope_prefix])}
-  end
 
-  def define_openerp_model(param, scope_prefix=nil, url=nil, database=nil, user_id=nil, pass=nil)
-    klass = Class.new(OpenObjectResource)
-    klass.ooor = self
-    klass.site = url || @base_url
-    klass.user = user_id
-    klass.password = pass
-    klass.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.polymorphic_m2o_relations = {}
-    klass.relations_keys = []
-    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"
-    (scope_prefix ? Object.const_get(scope_prefix) : Object).const_set(model_class_name, klass)
-    @loaded_models.push(klass)
-    klass
-  end
+    def define_openerp_model(param, scope_prefix=nil, url=nil, database=nil, user_id=nil, pass=nil)
+      klass = Class.new(OpenObjectResource)
+      klass.ooor = self
+      klass.site = url || @base_url
+      klass.user = user_id
+      klass.password = pass
+      klass.database = database
+      klass.openerp_model = param['model']
+      klass.openerp_id = url || param['id']
+      klass.info = (param['info'] || '').gsub("'",' ')
+      model_class_name = klass.class_name_from_model_key
+      klass.name = model_class_name
+      klass.state = param['state']
+      #klass.field_ids = param['field_id']
+      #klass.access_ids = param['access_ids']
+      klass.many2one_associations = {}
+      klass.one2many_associations = {}
+      klass.many2many_associations = {}
+      klass.polymorphic_m2o_associations = {}
+      klass.associations_keys = []
+      klass.fields = {}
+      klass.scope_prefix = scope_prefix
+      @logger.info "registering #{model_class_name} as an ActiveResource proxy for OpenObject #{param['model']} model"
+      (scope_prefix ? Object.const_get(scope_prefix) : Object).const_set(model_class_name, klass)
+      @loaded_models.push(klass)
+      klass
+    end
 
+  end
+  
+  if defined?(Rails) #Optional autoload in Rails:
+    if Rails.version[0] == "3"[0] #Rails 3 bootstrap
+      class Railtie < Rails::Railtie
+        initializer "ooor.middleware" do |app|
+          Ooor.default_config = Ooor.load_config(false, RAILS_ENV)
+          Ooor.default_ooor = Ooor.new(Ooor.default_config) if Ooor.default_config['bootstrap']
+        end
+      end
+    else #Rails 2.3.x bootstrap
+      Ooor.default_config = Ooor.load_config(false, RAILS_ENV)
+         Ooor.default_ooor = Ooor.new(Ooor.default_config) if Ooor.default_config['bootstrap']
+     end
+  end
 end
-
-if defined?(Rails) #Optionnal autoload in Rails:
-  Ooor.default_config = Ooor.load_config(false, RAILS_ENV)
-  Ooor.default_ooor = Ooor.new(Ooor.default_config) if Ooor.default_config['bootstrap']
-end