ooor 1.2.8 → 1.2.9

data/lib/app/models/common_service.rb

@@ -0,0 +1,26 @@
+#proxies all 'common' class of OpenERP server/bin/service/web_service.py properly
+module CommonService
+  def global_login(user, password)
+    @config[:username] = user
+    @config[:password] = password
+    client = OpenObjectResource.client(@base_url + "/common")
+    @config[:user_id] = OpenObjectResource.try_with_pretty_error_log { client.call("login", @config[:database], user, password) }
+    rescue Exception => error
+      @logger.error """login to OpenERP server failed:
+       #{error.inspect}
+       Are your sure the server is started? Are your login parameters correct? Can this server ping the OpenERP server?
+       login XML/RPC url was #{@config[:url].gsub(/\/$/,'') + "/common"}"""
+      raise
+  end
+
+  def login(user, password); global_login(user, password); end
+
+  #we generate methods handles for use in auto-completion tools such as jirb_swing
+  [:ir_get, :ir_set, :ir_del, :about, :logout, :timezone_get, :get_available_updates, :get_migration_scripts, :get_server_environment, :login_message, :check_connectivity].each do |meth|
+    self.instance_eval do
+      define_method meth do |*args|
+        OpenObjectResource.try_with_pretty_error_log { OpenObjectResource.client(@base_url + "/common").call(meth.to_s, *args) }
+      end
+    end
+  end
+end

data/lib/app/models/db_service.rb

@@ -0,0 +1,26 @@
+#proxies all 'db' class of OpenERP server/bin/service/web_service.py properly
+module DbService
+  def create(password=@config[:db_password], db_name='ooor_db', demo=true, lang='en-US', user_password=@config[:password] || 'admin')
+    process_id = OpenObjectResource.try_with_pretty_error_log { OpenObjectResource.client(@base_url + "/db").call("create", password, db_name, demo, lang, user_password) }
+    @config[:database] = db_name
+    @config[:username] = user_password
+    while get_progress('admin', process_id) == [0, []]
+      @logger.info "..."
+      sleep(0.5)
+    end
+    load_models()
+  end
+
+  def drop(password=@config[:db_password], db_name='ooor_db')
+    OpenObjectResource.try_with_pretty_error_log { OpenObjectResource.client(@base_url + "/db").call("drop", password, db_name) }
+  end
+
+  #we generate methods handles for use in auto-completion tools such as jirb_swing
+  [:get_progress, :dump, :restore, :rename, :db_exist, :list, :change_admin_password, :list_lang, :server_version, :migrate_databases].each do |meth|
+    self.instance_eval do
+      define_method meth do |*args|
+        OpenObjectResource.try_with_pretty_error_log { OpenObjectResource.client(@base_url + "/db").call(meth.to_s, *args) }
+      end
+    end
+  end
+end

data/lib/app/models/open_object_resource.rb

@@ -1,6 +1,7 @@
 require 'xmlrpc/client'
+require 'rubygems'
 require 'active_resource'
-require 'app/models/open_object_ui'
+require 'app/ui/form_model'
 require 'app/models/uml'
 require 'set'
 
@@ -14,8 +15,8 @@ class OpenObjectResource < ActiveResource::Base
 
     cattr_accessor :logger
     attr_accessor :openerp_id, :info, :access_ids, :name, :openerp_model, :field_ids, :state, #model class attributes assotiated to the OpenERP ir.model
-                  :fields, :fields_defined, :many2one_relations, :one2many_relations, :many2many_relations, :relations_keys,
-                  :openerp_database, :user_id, :scope_prefix, :ooor
+                  :fields, :fields_defined, :many2one_relations, :one2many_relations, :many2many_relations, :polymorphic_m2o_relations, :relations_keys,
+                  :database, :user_id, :scope_prefix, :ooor
 
     def class_name_from_model_key(model_key=self.openerp_model)
       model_key.split('.').collect {|name_part| name_part.capitalize}.join
@@ -24,7 +25,7 @@ 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, nil, nil, nil, nil, 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_key, self.scope_prefix)
       klass.reload_fields_definition unless klass.fields_defined
       klass
     end
@@ -41,15 +42,19 @@ class OpenObjectResource < ActiveResource::Base
             @one2many_relations[field.attributes['name']] = field
           when 'many2many'
             @many2many_relations[field.attributes['name']] = field
+          when 'reference'
+            @polymorphic_m2o_relations[field.attributes['name']] = field
           else
             @fields[field.attributes['name']] = field
           end
         end
-        @relations_keys = @many2one_relations.merge(@one2many_relations).merge(@many2many_relations).keys
+        @relations_keys = @many2one_relations.keys + @one2many_relations.keys + @many2many_relations.keys + @polymorphic_m2o_relations.keys
         (@fields.keys + @relations_keys).each do |meth| #generates method handlers for autompletion tools such as jirb_swing
-          self.instance_eval do
-            define_method meth do |*args|
-              self.send :method_missing, *[meth, *args]
+          unless self.respond_to?(meth)
+            self.instance_eval do
+              define_method meth do |*args|
+                self.send :method_missing, *[meth, *args]
+              end
             end
           end
         end
@@ -61,13 +66,13 @@ class OpenObjectResource < ActiveResource::Base
     # ******************** remote communication ********************
 
     #OpenERP search method
-    def search(domain, offset=0, limit=false, order=false, context={}, count=false)
+    def search(domain=[], offset=0, limit=false, order=false, context={}, count=false)
       rpc_execute('search', domain, offset, limit, order, context, count)
     end
 
     def client(url)
       @clients ||= {}
-      @clients[url] ||= XMLRPC::Client.new2(url)
+      @clients[url] ||= XMLRPC::Client.new2(url, nil, 180)
     end
 
     #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
@@ -108,8 +113,10 @@ class OpenObjectResource < ActiveResource::Base
         logger.debug "rpc_execute_with_all: rpc_method: 'create old_wizard_step' #{wizard_name}"
         wizard_id = try_with_pretty_error_log { cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/wizard").call("create",  @database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], wizard_name)) }
       end
-      logger.debug "rpc_execute_with_all: rpc_method: 'execute old_wizard_step' #{wizard_id}, #{{'model' => @openerp_model, 'form' => form, 'id' => ids[0], 'report_type' => report_type, 'ids' => ids}.inspect}, #{step}, #{context}"
-      [wizard_id, try_with_pretty_error_log { cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/wizard").call("execute",  @database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], wizard_id, {'model' => @openerp_model, 'form' => form, 'id' => ids[0], 'report_type' => report_type, 'ids' => ids}, step, context)) }]
+      params = {'model' => @openerp_model, 'form' => form, 'report_type' => report_type}
+      params.merge!({'id' => ids[0], 'ids' => ids}) if ids
+      logger.debug "rpc_execute_with_all: rpc_method: 'execute old_wizard_step' #{wizard_id}, #{params.inspect}, #{step}, #{context}"
+      [wizard_id, try_with_pretty_error_log { cast_answer_to_ruby!(client((@database && @site || @ooor.base_url) + "/wizard").call("execute",  @database || @ooor.config[:database], @user_id || @ooor.config[:user_id], @password || @ooor.config[:password], wizard_id, params, step, context)) }]
     end
 
     #grab the eventual error log from OpenERP response as OpenERP doesn't enforce carefuly
@@ -199,7 +206,7 @@ class OpenObjectResource < ActiveResource::Base
       !ids.empty? && ids[0].is_a?(Integer) && find_single(ids, options) || []
     end
 
-    # Find a single resource from the default URL
+    #actually finds many resources specified with scope = ids_array
     def find_single(scope, options)
       fields = options[:fields] || []
       context = options[:context] || {}
@@ -207,7 +214,7 @@ class OpenObjectResource < ActiveResource::Base
       is_collection = true
       scope = [scope] and is_collection = false if !scope.is_a? Array
       scope.map! do |item|
-        if item.is_a? String #triggers ir_model_data absolute reference lookup
+        if item.is_a?(String) && item.to_i == 0#triggers ir_model_data absolute reference lookup
           tab = item.split(".")
           domain = [['name', '=', tab[-1]]]
           domain += [['module', '=', tab[-2]]] if tab[-2]
@@ -321,6 +328,7 @@ class OpenObjectResource < ActiveResource::Base
     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"
     self.class.logger.debug msg
   end
@@ -389,7 +397,7 @@ 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], self.class.ooor.global_context)
+    FormModel.new(wizard_name, result[0], nil, nil, result[1], [self], self.class.ooor.global_context)
   end
 
   def type() method_missing(:type) end #skips deprecated Object#type method
@@ -405,6 +413,9 @@ class OpenObjectResource < ActiveResource::Base
       load_relation(self.class.one2many_relations[method_name].relation, @relations[method_name], *arguments)
     elsif self.class.many2many_relations.has_key?(method_name)
       load_relation(self.class.many2many_relations[method_name].relation, @relations[method_name], *arguments)
+    elsif self.class.polymorphic_m2o_relations.has_key?(method_name)
+      values = @relations[method_name].split(',')
+      load_relation(values[0], values[1].to_i, *arguments)
     else
       false
     end
@@ -441,18 +452,28 @@ class OpenObjectResource < ActiveResource::Base
 
     #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]
-        @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]
+      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
-    super
+
+    if id
+      arguments += [{}] unless arguments.last.is_a?(Hash)
+      self.class.rpc_execute(method_key, [id], *arguments) #we assume that's an action
+    else
+      super
+    end
 
   rescue RuntimeError
     raise

data/lib/app/models/uml.rb

@@ -5,7 +5,7 @@ module UML
 
   def print_uml(*options)
     ooor = self.class.ooor
-    UML.print_uml(ooor.config[:models] && ooor.all_loaded_models.select {|model| ooor.config[:models].index(model.openerp_model)} || ooor.all_loaded_models, options)
+    UML.print_uml(ooor.config[:models] && ooor.loaded_models.select {|model| ooor.config[:models].index(model.openerp_model)} || ooor.loaded_models, options)
   end
 
   module ClassMethods

data/lib/app/ui/action_window.rb

@@ -0,0 +1,11 @@
+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
+      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

@@ -0,0 +1,39 @@
+require 'app/ui/form_model'
+require 'app/ui/menu'
+require 'app/ui/action_window'
+
+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
+
+  #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 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

data/lib/app/ui/form_model.rb

@@ -0,0 +1,81 @@
+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'])
+    end
+  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)}"
+        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'
+        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
+  end
+
+  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]
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/app/ui/menu.rb

@@ -0,0 +1,16 @@
+require 'app/ui/action_window'
+
+module MenuModule
+
+  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 open(mode='tree', ids=nil)
+    menu_action.open(mode, ids)
+  end
+end

data/lib/ooor.rb

@@ -1,12 +1,18 @@
 require 'logger'
-require 'xmlrpc/client'
 require 'app/models/open_object_resource'
 require 'app/models/uml'
+require 'app/models/db_service'
+require 'app/models/common_service'
+require 'app/ui/client_base'
 
 class Ooor
   include UML
+  include DbService
+  include CommonService
+  include ClientBase
 
-  attr_accessor :logger, :config, :all_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)
@@ -20,50 +26,39 @@ class Ooor
     raise
   end
 
-  def global_login(user, password)
-    @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 Exception => error
-      @logger.error """login to OpenERP server failed:
-       #{error.inspect}
-       Are your sure the server is started? Are your login parameters correct? Can this server ping the OpenERP server?
-       login XML/RPC url was #{@config[:url].gsub(/\/$/,'') + "/common"}"""
-      raise
-  end
-
   def initialize(config, env=false)
     @config = config.is_a?(String) ? Ooor.load_config(config, env) : config
     @config.symbolize_keys!
-    @logger = ((defined?(RAILS_ENV) && $0 != 'irb') ? Rails.logger : Logger.new(STDOUT))
+    @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(/\/$/,'')
-    @global_context = config[:global_context] || {}
-
+    @loaded_models = []
     scope = Module.new and Object.const_set(config[:scope_prefix], scope) if config[:scope_prefix]
+    if config[:database]
+      load_models()
+    end
+  end
 
-    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])
-    define_openerp_model("ir.model.data", nil, nil, nil, nil, config[:scope_prefix])
+  def const_get(model_key)
+    @ir_model_class.const_get(model_key)
+  end
 
-    if config[:models] #we load only a customized subset of the OpenERP models
-      models = @ir_model_class.find(:all, :domain => [['model', 'in', config[:models]]])
+  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("ir.model", @config[:scope_prefix])
+    define_openerp_model("ir.model.fields", @config[:scope_prefix])
+    if to_load_models #we load only a customized subset of the OpenERP models
+      models = @ir_model_class.find(:all, :domain => [['model', 'in', to_load_models]])
     else #we load all the models
-      models = @ir_model_class.find(:all).reject {|model| ["ir.model", "ir.model.fields", "ir.model.data"].index model.model}
+      models = @ir_model_class.find(:all).reject {|model| ["ir.model", "ir.model.fields"].index model.model}
     end
-    models.each {|openerp_model| define_openerp_model(openerp_model, nil, nil, nil, nil, config[:scope_prefix])}
-  end
-
-  module Test
-    
+    @global_context.merge!({}).merge!(@config[:global_context] || {})
+    models.each {|openerp_model| define_openerp_model(openerp_model, @config[:scope_prefix])}
   end
 
-  def define_openerp_model(arg, url, database, user_id, pass, scope_prefix)
+  def define_openerp_model(arg, scope_prefix=nil, url=nil, database=nil, user_id=nil, pass=nil)
     if arg.is_a?(String) && arg != 'ir.model' && arg != 'ir.model.fields'
       arg = @ir_model_class.find(:first, :domain => [['model', '=', arg]])
     end
@@ -73,7 +68,7 @@ class Ooor
     klass.site = url || @base_url
     klass.user = user_id
     klass.password = pass
-    klass.openerp_database = database
+    klass.database = database
     klass.openerp_model = param['model']
     klass.openerp_id = url || param['id']
     klass.info = (param['info'] || '').gsub("'",' ')
@@ -84,20 +79,20 @@ class Ooor
     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)
-    @all_loaded_models.push(klass)
+    @loaded_models.push(klass)
     klass
   end
 
 end
 
-#Optionnal Rails settings:
-if defined?(Rails)
-  config = Ooor.load_config(false, RAILS_ENV)
-  OOOR = Ooor.new(config) if config['bootstrap']
+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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 2
-  - 8
-  version: 1.2.8
+  - 9
+  version: 1.2.9
 platform: ruby
 authors: 
 - Raphael Valyi - www.akretion.com
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-02 00:00:00 -03:00
+date: 2010-03-10 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,10 +43,15 @@ files:
 - README.md
 - MIT-LICENSE
 - lib/ooor.rb
+- ooor.yml
 - lib/app/models/open_object_resource.rb
-- lib/app/models/open_object_ui.rb
 - lib/app/models/uml.rb
-- ooor.yml
+- lib/app/models/db_service.rb
+- lib/app/models/common_service.rb
+- lib/app/ui/action_window.rb
+- lib/app/ui/client_base.rb
+- lib/app/ui/form_model.rb
+- lib/app/ui/menu.rb
 has_rdoc: true
 homepage: http://github.com/rvalyi/ooor
 licenses: []

data/lib/app/models/open_object_ui.rb

@@ -1,45 +0,0 @@
-class OpenObjectLayoutedFields
-  attr_accessor :arch, :fields
-
-  def initialize(arch, fields)
-    @arch = arch
-    @fields = fields
-  end
-end
-
-class OpenObjectWizard < OpenObjectLayoutedFields
-  attr_accessor :name, :id, :datas, :arch, :fields, :type, :state, :open_object_resources
-
-  def initialize(name, id, data, open_object_resources, wizard_context)
-    super(data['arch'], data['fields'])
-    @name = name
-    @id = id
-    @open_object_resources = open_object_resources
-    @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 = @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.reload_from_record!(open_object_resource.class.find(open_object_resource.id, :context => context))
-      end
-      @arch = data[1]['arch']
-      @fields = data[1]['fields']
-      @datas = data[1]['datas'].symbolize_keys!
-      @type = data[1]['type']
-      @state = data[1]['state']
-      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, @id, values, context)
-    end
-  end
-
-end