ooor 1.9.2 → 2.0.0

data/lib/app/models/services.rb

@@ -1,47 +0,0 @@
-#    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2013 Akretion LTDA (<http://www.akretion.com>).
-#    Author: Raphaël Valyi
-#    Licensed under the MIT license, see MIT-LICENSE file
-
-#proxies for server/openerp/service/web_services.py
-module Ooor
-  module CommonService
-    %w[ir_get ir_set ir_del about login logout timezone_get get_available_updates get_migration_scripts get_server_environment login_message check_connectivity about get_stats list_http_services version authenticate get_available_updates set_loglevel get_os_time get_sqlcount].each do |meth|
-      self.instance_eval do
-        define_method meth do |*args|
-          get_rpc_client(@base_url + "/common").call(meth, *args)
-        end
-      end
-    end
-  end
-
-  module DbService
-    def create(password=@config[:db_password], db_name='ooor_test', demo=true, lang='en_US', user_password=@config[:password] || 'admin')
-      process_id = get_rpc_client(@base_url + "/db").call("create", password, db_name, demo, lang, user_password)
-      sleep(2)
-      while get_progress(password, process_id)[0] != 1
-        @logger.info "..."
-        sleep(0.5)
-      end
-      global_login('admin', user_password, db_name, false)
-    end
-
-    %w[get_progress drop dump restore rename db_exist list change_admin_password list_lang server_version migrate_databases create_database duplicate_database].each do |meth|
-      self.instance_eval do
-        define_method meth do |*args|
-          get_rpc_client(@base_url + "/db").call(meth, *args)
-        end
-      end
-    end
-  end
-
-  module ReportService
-    %w[report report_get render_report].each do |meth|
-      self.instance_eval do
-        define_method meth do
-          |*args| get_rpc_client(@base_url + "/report").call(meth, *args)
-        end
-      end
-    end
-  end
-end

data/lib/app/models/type_casting.rb

@@ -1,134 +0,0 @@
-#    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2012 Akretion LTDA (<http://www.akretion.com>).
-#    Author: Raphaël Valyi
-#    Licensed under the MIT license, see MIT-LICENSE file
-
-module Ooor
-  module TypeCasting
-  
-    def self.included(base) base.extend(ClassMethods) end
-  
-    module ClassMethods
-      
-      def openerp_string_domain_to_ruby(string_domain)
-        eval(string_domain.gsub('(', '[').gsub(')',']'))
-      end
-      
-      def to_openerp_domain(domain)
-        if domain.is_a?(Hash)
-          return domain.map{|k,v| [k.to_s, '=', v]}
-        elsif domain == []
-          return []
-        elsif domain.is_a?(Array) && !domain.last.is_a?(Array)
-          return [domain]
-        else
-          return domain
-        end
-      end
-
-      def clean_request_args!(args)
-        if args[-1].is_a? Hash
-          args[-1] = @ooor.global_context.merge(args[-1])
-        elsif args.is_a?(Array)
-          args.map! {|v| value_to_openerp(v)}
-          args += [@ooor.global_context]
-        end
-        cast_map_to_openerp!(args[-2]) if args[-2].is_a? Hash
-      end
-      
-      def value_to_openerp(v)
-        if v == nil
-          return false
-        elsif !v.is_a?(Integer) && !v.is_a?(Float) && v.is_a?(Numeric) && v.respond_to?(:to_f)
-          return v.to_f
-        elsif !v.is_a?(Numeric) && !v.is_a?(Integer) && v.respond_to?(:sec) && v.respond_to?(:year)#really ensure that's a datetime type
-          return "%d-%02d-%02d %02d:%02d:%02d" % [v.year, v.month, v.day, v.hour, v.min, v.sec]
-        elsif !v.is_a?(Numeric) && !v.is_a?(Integer) && v.respond_to?(:day) && v.respond_to?(:year)#really ensure that's a date type
-          return "%d-%02d-%02d" % [v.year, v.month, v.day]
-        elsif v == "false" #may happen with OOORBIT
-          return false
-        else
-          v
-        end
-      end
-
-      def cast_map_to_openerp!(map)
-        map.each do |k, v|
-          map[k] = value_to_openerp(v)
-        end
-      end
-
-      def cast_answer_to_ruby!(answer)
-        def cast_map_to_ruby!(map)
-          map.each do |k, v|
-            if self.fields[k] && v.is_a?(String) && !v.empty?
-              case self.fields[k]['type']
-              when 'datetime'
-                map[k] = DateTime.parse(v)
-              when 'date'
-                map[k] = Date.parse(v)
-              end
-            end
-          end
-        end
-
-        if answer.is_a?(Array)
-          answer.each {|item| self.cast_map_to_ruby!(item) if item.is_a? Hash}
-        elsif answer.is_a?(Hash)
-          self.cast_map_to_ruby!(answer)
-        else
-          answer
-        end
-      end
-      
-    end
-    
-    def to_openerp_hash!
-      cast_relations_to_openerp!
-      blacklist = %w[id write_date create_date write_ui create_ui]
-      @attributes.reject {|k, v| blacklist.index(k)}.merge(@associations)
-    end
-    
-    def cast_relations_to_openerp!
-      @associations.reject! do |k, v| #reject non assigned many2one or empty list
-        v.is_a?(Array) && (v.size == 0 or v[1].is_a?(String))
-      end
-
-      def cast_relation(k, v, one2many_associations, many2many_associations)
-        if one2many_associations[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
-              if value.is_a?(Hash)
-                [0, 0, value]
-              else
-                [1, value, {}]
-              end
-            end
-          end
-        elsif many2many_associations[k]
-          return v = [[6, 0, v]]
-        end
-      end
-
-      @associations.each do |k, v| #see OpenERP awkward associations API
-        #already casted, possibly before server error!
-        next if (v.is_a?(Array) && v.size == 1 && v[0].is_a?(Array)) \
-                || self.class.many2one_associations[k] \
-                || !v.is_a?(Array)
-        new_rel = self.cast_relation(k, v, self.class.one2many_associations, self.class.many2many_associations)
-        if new_rel #matches a known o2m or m2m
-          @associations[k] = new_rel
-        else
-          self.class.many2one_associations.each do |k2, field| #try to cast the association to an inherited o2m or m2m:
-            linked_class = self.class.const_get(field['relation'])
-            new_rel = self.cast_relation(k, v, linked_class.one2many_associations, linked_class.many2many_associations)
-            @associations[k] = new_rel and break if new_rel
-          end
-        end
-      end
-    end
-    
-  end
-end

data/lib/app/models/uml.rb

@@ -1,210 +0,0 @@
-#    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2012 Akretion LTDA (<http://www.akretion.com>).
-#    Author: Raphaël Valyi
-#    Licensed under the MIT license, see MIT-LICENSE file
-
-module Ooor
-  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 print_uml(options={})
-      ooor = self.class.ooor
-      UML.print_uml(ooor.config[:models] && ooor.loaded_models.select {|model| ooor.config[:models].index(model.openerp_model)} || ooor.loaded_models, options)
-    end
-
-    def serve_uml(options={})#TODO port
-      ooor = self
-      require 'sinatra'
-      set :public, File.dirname(__FILE__) + '/../../'
-
-      get '/model/:model_name' do
-        model_name = params[:model_name]
-        model = ooor.const_get(model_name)
-        model.print_uml
-        s = ""#"Hello world! #{model_name}"
-        s << "<IMG SRC='/x.png' USEMAP='#UMLbyOOOR' />"
-        f=File.open('x.map')
-        f.each_line {|l| s << l}
-        s
-      end
-
-      Sinatra::Application.run!
-    end
-
-    def self.display_fields(clazz)
-      s = ""
-      clazz.reload_fields_definition if clazz.fields.empty?
-      #clazz.fields.sort {|a,b| a[1]['type'] <=> b[1]['type']}.each {|i| s << "+ #{i[1]['type']} : #{i[0]}\\l\\n"}
-    clazz.fields.sort {|a,b| a[1]['type'] <=> b[1]['type']}.each {|i| s << "<TR><TD COLSPAN=\"2\" BGCOLOR=\"#bed1b8\" ALIGN=\"LEFT\">#{i[0]}</TD><TD ALIGN=\"LEFT\">#{i[1]['type']}</TD></TR>\\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)
-      return if classes.empty?
-      local = true
-      detailed = true
-      file_name = options[:file_name] || classes[0].name
-      if classes.size > 8
-        enabled_targets = classes.map {|i| i.openerp_model} #classes[0].ooor.config[:models] #defines the scope of the UML for option local
-      else
-        enabled_targets = classes[0].ooor.config[:models] #defines the scope of the UML for option local
-      end
-
-      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("#{file_name}.dot", 'w') do |f|
-        f << <<-eos
-        digraph UMLbyOOOR {
-            fontname = "Helvetica"
-            #{classes.size < 5 && "layout = fdp" || ""}
-            fontsize = 11
-            splines = polyline
-            label = "*** generated by OOOR by www.akretion.com ***"
-            node [
-                    fontname = "Helvetica"
-                    fontsize = 11
-                    shape = "record"
-                    fillcolor=orange
-                    style="rounded,filled"
-            ]
-            edge [
-                    arrowhead = "none"
-                    fontname = "Helvetica"
-                    fontsize = 9
-            ]
-        eos
-
-        #UML nodes definitions
-        ((connex_classes - classes) + classes - [IrModel, IrModel.const_get('ir.model.fields')]).each do |model|
-          #f << " #{model} [ label = \"{#{model.name}#{detailed ? '|' + display_fields(model) : ''}}\" URL=\"/model/#{model.openerp_model}\"];\n"
-      f << "#{model}[label=<<TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" BGCOLOR=\"#ffffff\"><TR><TD COLSPAN=\"3\" BGCOLOR=\"#9bab96\" ALIGN=\"CENTER\">#{model.name}</TD></TR>#{(classes.index(model) || classes.size == 1) && display_fields(model) || ''}</TABLE>> URL=\"/model/#{model.openerp_model}\"];\n"
-        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  #{file_name}.png"
-        #system(cmd_line1)
-      rescue
-      end
-      #cmd_line2 = "dot -Tpng uml.dot -o uml.png"
-      cmd_line2 = "dot -Tcmapx -o#{file_name}.map -Tpng -o#{file_name}.png #{file_name}.dot"
-      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_associations.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_associations.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_associations.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'])
-        model.const_get(field['relation'])
-      else
-        false
-      end
-    end
-  end
-end

data/lib/app/ui/action_window.rb

@@ -1,96 +0,0 @@
-#    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2012 Akretion LTDA (<http://www.akretion.com>).
-#    Author: Raphaël Valyi
-#    Licensed under the MIT license, see MIT-LICENSE file
-
-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_url(mode='tree', id=nil, tab=nil) #TODO deal with visible tab in Javascript, possibly hacking web-client
-        url = "#{self.ooor.base_url.gsub("xmlrpc", "web/webclient/home")}#action_id=#{@openerp_act_window.id}&view_type=#{mode}"
-        url += "&id=#{id}" if id
-      end
-
-      def get_view_id(mode)
-        ids = IrActionsAct_window.read(@openerp_act_window.id, ["view_ids"])["view_ids"]
-        IrActionsAct_windowView.read(ids, ["view_mode", "view_id"]).each do |view_hash|
-          return view_hash["view_id"][0] if view_hash["view_id"] && 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
-
-      def method_missing(method, *args, &block)
-        @klass.send(method, *args, &block)
-      end
-    
-    end
-    
-    
-  end
-end