Module: ModFactor::Owner

Defined in:
lib/mod_factor/owner.rb

Defined Under Namespace

Modules: ClassMethods

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
# File 'lib/mod_factor/owner.rb', line 4

def self.included base
  base.extend ClassMethods

  base.after_initialize do |obj|
    if base.instance_variable_defined? :@factor_model
      factor_model = base.instance_variable_get :@factor_model
      obj.send(factor_model).each do |factor|
        obj.instance_variable_set "@#{factor.key.to_sym}", factor.amount
        obj.factor_hash[factor.key.to_sym] = factor.amount
      end
      base.factor_define.keys.each do |key|
        if base.factor_define[key][:default] && obj.send(key).nil?
          obj.instance_variable_set "@#{key}", base.factor_define[key][:default]
        end
      end

    end
    if base.instance_variable_defined? :@property_model
      property_model = base.instance_variable_get :@property_model
      obj.send(property_model).each do |property|
        define = base.property_define[property.key.to_sym]
        value = property.value
        value = case define[:type]
                when :decimal
                  BigDecimal.new value.to_s
                when :integer
                  value.to_i
                when :boolean
                  if value.is_a?(FalseClass) ||
                    value.nil? ||
                    value == 0 ||
                    value =~ /^(f|false|0)$/i ||
                    (value.respond_to? :empty? and value.empty?)
                    false
                  else
                    true
                  end
                else
                  property.value
                end

        obj.instance_variable_set "@#{property.key.to_sym}", value
        obj.property_hash[property.key.to_sym] = value
      end
      base.property_define.keys.each do |key|
        if base.property_define[key][:default] && obj.send(key).nil?
          obj.instance_variable_set "@#{key}", base.property_define[key][:default]
        end
      end

    end
  end

  base.after_save do |obj|
    if base.instance_variable_defined? :@factor_model
      factor_model = base.instance_variable_get :@factor_model

      factor_changes.each do |key|
        factor = obj.send(factor_model).find_or_initialize_by_key key
        factor.amount = BigDecimal.new(obj.send(key).to_s)
        factor.save!
        obj.instance_variable_set "@#{key}", factor.amount
      end
      obj.reload
    end

    if base.instance_variable_defined? :@property_model
      property_model = base.instance_variable_get :@property_model

      property_changes.each do |key|
        property = obj.send(property_model).find_or_initialize_by_key key
        property.value = obj.send(key)
        property.save!
        obj.instance_variable_set "@#{key}", property.value
      end
      obj.reload
    end

  end
end

Instance Method Details

#calculate(options = {}) ⇒ Object



154
155
156
157
158
159
160
161
162
# File 'lib/mod_factor/owner.rb', line 154

def calculate options={}
  self.class.generate_list.each do |key|
    if (condition = self.class.factor_define[key][:condition]).nil? || self.instance_exec(options, &condition)
      raise "formula should be defined when generate" unless callable = self.class.factor_define[key][:formula]

      instance_variable_set "@#{key}", self.instance_exec(options, &callable)
    end
  end
end

#calculate!(options = {}) ⇒ Object



164
165
166
167
# File 'lib/mod_factor/owner.rb', line 164

def calculate! options={}
  calculate options
  save!
end

#changed_for_autosave?Boolean

Returns:

  • (Boolean)


169
170
171
# File 'lib/mod_factor/owner.rb', line 169

def changed_for_autosave?
  !factor_changes.empty? || !property_changes.empty? || super
end

#factor_changesObject



135
136
137
138
139
# File 'lib/mod_factor/owner.rb', line 135

def factor_changes
  self.class.factor_define.keys.select do |key|
    factor_hash[key] != __send__(key)
  end
end

#factor_hashObject



128
129
130
131
132
133
# File 'lib/mod_factor/owner.rb', line 128

def factor_hash
  @factor_hash ||= self.class.factor_define.keys.inject({}) do 
    |out, item| out[item] = self.class.factor_define[item][:default]
    out
  end
end

#property_changesObject



148
149
150
151
152
# File 'lib/mod_factor/owner.rb', line 148

def property_changes
  self.class.property_define.keys.select do |key|
    property_hash[key] != __send__(key)
  end
end

#property_hashObject



141
142
143
144
145
146
# File 'lib/mod_factor/owner.rb', line 141

def property_hash
  @property_hash ||= self.class.factor_define.keys.inject({}) do 
    |out, item| out[item] = self.class.factor_define[item][:default]
    out
  end
end