Module: Ooor::TypeCasting::ClassMethods

Defined in:
lib/ooor/type_casting.rb

Instance Method Summary collapse

Instance Method Details

#cast_answer_to_ruby!(answer) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/ooor/type_casting.rb', line 79

def cast_answer_to_ruby!(answer)
  def cast_map_to_ruby!(map)
    map.each do |k, v|
      if self.t.fields[k] && v.is_a?(String) && !v.empty?
        case self.t.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

#cast_map_to_ruby!(map) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/ooor/type_casting.rb', line 80

def cast_map_to_ruby!(map)
  map.each do |k, v|
    if self.t.fields[k] && v.is_a?(String) && !v.empty?
      case self.t.fields[k]['type']
      when 'datetime'
        map[k] = DateTime.parse(v)
      when 'date'
        map[k] = Date.parse(v)
      end
    end
  end
end

#cast_request_to_openerp(request) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/ooor/type_casting.rb', line 66

def cast_request_to_openerp(request)
  if request.is_a?(Array)
    request.map { |item| cast_request_to_openerp(item) }
  elsif request.is_a?(Hash)
    request2 = {}
    request.each do |k, v|
      request2[k] = cast_request_to_openerp(v)
    end
  else
    value_to_openerp(request)
  end
end

#openerp_string_domain_to_ruby(string_domain) ⇒ Object

FIXME: used? broken?



15
16
17
 
# File 'lib/ooor/type_casting.rb', line 15

def openerp_string_domain_to_ruby(string_domain) #FIXME: used? broken?
  eval(string_domain.gsub('(', '[').gsub(')',']'))
end

#to_openerp_domain(domain) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/ooor/type_casting.rb', line 19

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

#to_rails_type(type) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/ooor/type_casting.rb', line 31

def to_rails_type(type)
  case type.to_sym
  when :char
    :string
  when :binary
    :file
  when :many2one
    :belongs_to
  when :one2many
    :has_many
  when :many2many
    :has_and_belongs_to_many
  else
    type.to_sym
  end
end

#value_to_openerp(v) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/ooor/type_casting.rb', line 48

def value_to_openerp(v)
  if v == nil || v == ""
    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
  elsif v.respond_to?(:read)
    return Base64.encode64(v.read())
  else
    v
  end
end