ooor 1.4.2 → 1.5.0

data/lib/app/models/relation.rb

@@ -0,0 +1,145 @@
+#    OOOR: Open Object On Rails
+#    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
+#    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/>.
+
+#TODO chainability of where via scopes
+#TODO include relations for single read
+
+module Ooor
+  # = Similar to Active Record Relation
+  class Relation
+    
+    attr_reader :klass, :loaded
+    attr_accessor :context, :count_field, :includes_values, :eager_load_values, :preload_values,
+                  :select_values, :group_values, :order_values, :reorder_flag, :joins_values, :where_values, :having_values,
+                  :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value
+    alias :loaded? :loaded
+    
+    def build_where(opts, other = [])
+      case opts
+      when Array
+        [opts]
+      when Hash
+        opts.keys.map {|key|["#{key}", "=", opts[key]]}
+      end
+    end
+    
+    def where(opts, *rest)
+      relation = clone
+      relation.where_values += build_where(opts, rest) unless opts.blank?
+      relation
+    end
+
+#    def having(*args)
+#      relation = clone
+#      relation.having_values += build_where(*args) unless args.blank?
+#      relation
+#    end
+
+    def limit(value)
+      relation = clone
+      relation.limit_value = value
+      relation
+    end
+
+    def offset(value)
+      relation = clone
+      relation.offset_value = value
+      relation
+    end
+    
+    def order(*args)
+      relation = clone
+      relation.order_values += args.flatten unless args.blank?
+      relation
+    end
+    
+    def count(column_name = nil, options = {})
+      column_name, options = nil, column_name if column_name.is_a?(Hash)
+      calculate(:count, column_name, options)
+    end
+    
+    def initialize(klass)
+      @klass = klass
+      @where_values = []
+      @loaded = false
+      @context = {}
+      @count_field = false
+      @limit_value = false
+      @offset_value = false
+      @order_values = []
+    end
+    
+    def new(*args, &block)
+      #TODO inject current domain in *args
+      @klass.new(*args, &block)
+    end
+    
+    def reload
+      reset
+      to_a # force reload
+      self
+    end
+
+    def initialize_copy(other)
+      reset
+    end
+
+    def reset
+      @first = @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil
+      @should_eager_load = @join_dependency = nil
+      @records = []
+      self
+    end
+
+    # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:all)</tt>.
+    def all(*args)
+      #args.any? ? apply_finder_options(args.first).to_a : to_a TODO
+      to_a
+    end
+
+    def to_a
+      return @records if loaded?
+      if @order_values.empty?
+        search_order = false
+      else
+        search_order = @order_values.join(", ")
+      end
+      ids = @klass.rpc_execute('search', @where_values, @offset_value, @limit_value, search_order, @context, @count_field)
+      @records = @klass.find(ids)
+      @loaded = true
+      @records
+    end
+  
+    def eager_loading?
+      false
+    end
+    
+    protected
+
+    def method_missing(method, *args, &block)
+      if Array.method_defined?(method)
+        to_a.send(method, *args, &block)
+      elsif @klass.respond_to?(method)
+        @klass.send(method, *args, &block)
+      else
+        @klass.rpc_execute(method.to_s, to_a.map {|record| record.id}, *args)
+      end
+    end
+
+  end
+end

data/lib/app/models/type_casting.rb

@@ -0,0 +1,119 @@
+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 += [@ooor.global_context]
+        end
+        cast_request_to_openerp!(args[-2]) if args[-2].is_a? Hash
+      end
+
+      def cast_request_to_openerp!(map)
+        map.each do |k, v|
+          if v == nil
+            map[k] = false
+          elsif !v.is_a?(Integer) && !v.is_a?(Float) && v.is_a?(Numeric) && v.respond_to?(:to_f)
+            map[k] = 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
+            map[k] = "#{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
+            map[k] = "#{v.year}-#{v.month}-#{v.day}"
+          end
+        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] = Time.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!
+      @attributes.reject {|k, v| k == 'id'}.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,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,183 +14,206 @@
 #
 #    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
+  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)
 
-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 self.included(base) base.extend(ClassMethods) end
-
-  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
-
-  module ClassMethods
     def print_uml(*options)
-      UML.print_uml([self], 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
-  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"}
-    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"
+    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
 
-      #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
+      Sinatra::Application.run!
+    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"
+    module ClassMethods
+      def print_uml(*options)
+        UML.print_uml([self], options)
       end
-
-      f << "}"
     end
 
-    begin
-      cmd_line1 = "rm  uml.png"
-      system(cmd_line1)
-    rescue
+    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
-    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
+    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 UMLbyOOOR {
+            fontname = "Helvetica"
+            fontsize = 11
+            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>#{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  uml.png"
+        #system(cmd_line1)
+      rescue
+      end
+      #cmd_line2 = "dot -Tpng uml.dot -o uml.png"
+      cmd_line2 = "dot -Tcmapx -ox.map -Tpng -ox.png uml.dot"
+      system(cmd_line2)
     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]]
+    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
 
-      #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], []]
+     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
 
+      end
+      connex_classes
     end
-    connex_classes
-  end
 
-  private
+    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
+    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