smerp-quotation 0.1.0

data/lib/smerp/quotation/ar_model/quotation_item.rb

@@ -0,0 +1,417 @@
+
+require 'acts_as_tree'
+
+module Smerp
+
+  module Quotation
+
+    module ArModel
+      class QuotationItem < Ca::DataStore::Ar::Model
+
+        include TR::CondUtils
+
+        include TeLogger::TeLogHelper
+        teLogger_tag :quotItmMdl
+
+        include ActsAsTree
+        acts_as_tree
+
+        belongs_to :quotation
+
+        belongs_to :quotable, polymorphic: true
+        # polymorphic on model of products / resources
+        # has_many :quotation_items, as: :quotable
+
+        belongs_to :quotation_item_group, optional: true
+
+        before_save :update_total
+        after_save :update_group_total, :update_quotation_total 
+
+        before_destroy :update_total
+        after_destroy :update_group_total, :update_quotation_total 
+
+        def update_total
+
+          if children.length == 0
+            self.line_total = self.quantity * self.unit_price  if self.quantity_changed? or self.unit_price_changed? 
+            self.line_total_after_discount = self.line_total 
+            self.line_total_with_tax = self.line_total
+          end
+
+          if self.quantity_changed?
+            # Change unit_price for record that has children
+            # since unit_price is 'derived' from children's line_total
+            if self.quantity > 0
+              self.unit_price = self.line_total / self.quantity
+            else
+              self.unit_price = 0.0
+              self.line_total = 0.0
+            end
+          end
+
+          res = { local: [], quotation: [] }
+          extCals = { local: [], quotation: [] }
+          if not_empty?(self.extended_calculators)
+            extCals = YAML.load(self.extended_calculators)
+          end
+
+          extCals[:local].each do |ec|
+            teLogger.debug "Executing item calculator : #{ec.inspect}"
+            ec.calculate(self)
+            ec.owner_id = self.id if is_empty?(ec.owner_id) and not self.new_record?
+            res[:local] << ec.for_storage
+          end
+
+          if self.new_record?
+            
+            # apply global calculator from quotation
+            gExtCals = []
+            if not_empty?(self.quotation.extended_calculators)
+              gExtCals = YAML.load(self.quotation.extended_calculators) 
+            end
+
+            #cals = []
+            gExtCals.each do |ec|
+
+              teLogger.debug "Executing item-quotation calculator : #{ec.inspect}"
+              ec.calculate(self)
+              ec.owner_id = self.quotation.id if is_empty?(ec.owner_id)
+              res[:quotation] << ec.for_storage
+
+            end
+
+          else
+
+            extCals[:quotation].each do |ec|
+              teLogger.debug "Executing item-quotation calculator : #{ec.inspect}"
+              ec.calculate(self)
+              ec.owner_id = self.quotation.id if is_empty?(ec.owner_id)
+              res[:quotation] << ec.for_storage
+            end
+            
+          end
+
+
+          # after calculate, remove item with zero params
+          res[:local].delete_if { |c| 
+            case c.params
+            when Smerp::Common::FinUtils::Percent
+              c.params.value == 0
+            else
+              c.params.to_i == 0
+            end
+          }
+
+          res[:quotation].delete_if { |c| 
+            case c.params
+            when Smerp::Common::FinUtils::Percent
+              c.params.value == 0
+            else
+              c.params.to_i == 0
+            end
+          }
+
+          self.extended_calculators = YAML.dump(res)
+
+        end
+
+        def update_group_total
+
+          grp = self.quotation_item_group
+          if not grp.nil?
+            # update total
+            grp.group_total = grp.children.sum(:group_total) + grp.quotation_items.sum(:line_total)
+            grp.group_discount = grp.children.sum(:group_discount) + grp.quotation_items.sum(:discount)
+            grp.group_tax = grp.children.sum(:group_tax) + grp.quotation_items.sum(:tax)
+            grp.save
+          end
+
+        end
+
+        def update_quotation_total
+
+          if not self.parent.nil? 
+
+            self.parent.reload
+
+            if self.parent.is_children_linked?
+
+              teLogger.debug "Parent #{self.parent.inspect} IS children linked" 
+              # 
+              # Children of another QuotationItem
+              #
+              if self.parent.quantity > 0
+                # for children item that has a parent
+                # update parent line_total
+                self.parent.line_total = self.parent.children.sum(:line_total)
+
+                # update unit_price since line_total is sum of children's line_total
+                self.parent.unit_price = self.parent.line_total / self.parent.quantity
+
+                self.parent.discount = self.parent.children.sum(:discount)
+                self.parent.line_total_after_discount = self.parent.children.sum(:line_total_after_discount)
+                self.parent.tax = self.parent.children.sum(:tax)
+                self.parent.line_total_with_tax = self.parent.children.sum(:line_total_with_tax)
+
+                teLogger.debug "After update from children : #{self.parent.inspect}"
+
+              else
+
+                self.parent.line_total = 0.0
+                self.parent.unit_price = 0.0
+                self.parent.discount = 0.0
+                self.parent.line_total_after_discount = 0.0
+                self.parent.tax = 0.0
+                self.parent.line_total_with_tax = 0.0
+              end
+
+              self.parent.save
+
+            else
+              teLogger.debug "Parent #{self.parent.inspect} is NOT children linked. Skipping children update to parent." 
+            end
+
+          end
+
+          self.quotation.total = self.quotation.quotation_items.where(["parent_id is null"]).sum(:line_total)
+          self.quotation.total_discount = self.quotation.quotation_items.where(["parent_id is null"]).sum(:discount)
+          self.quotation.total_after_discount = self.quotation.quotation_items.where(["parent_id is null"]).sum(:line_total_after_discount)
+          self.quotation.total_tax = self.quotation.quotation_items.where(["parent_id is null"]).sum(:tax)
+          self.quotation.total_with_tax = self.quotation.quotation_items.where(["parent_id is null"]).sum(:line_total_with_tax)
+
+          self.quotation.save
+        end
+
+
+        def recalculate
+          
+          if self.quantity_changed? or self.unit_price_changed?
+            self.line_total = self.quantity * self.unit_price
+          end
+
+          if self.discount_changed?
+            self.line_total_after_discount = self.line_total - self.discount
+          end
+
+        end
+
+
+        #def children
+        #  if @_children.nil?
+        #    @_children = QuotationItem.where(["parent_id = ?",self.id])
+        #  end
+        #  @_children
+        #end
+
+        #def parent
+        #  if self.parent_id.nil?
+        #    nil
+        #  else
+        #    if @_parent.nil?
+        #      @_parent = QuotationItem.find(self.parent_id)
+        #    end
+        #    @_parent
+        #  end
+        #end
+
+        def break_children_link
+
+          self.children_link = 0
+          # all fields updated by children shall be reset
+          self.line_total = 0.0
+          self.unit_price = 0.0
+          self.discount = 0.0
+          self.line_total_after_discount = 0.0
+          self.tax = 0.0
+          self.line_total_with_tax = 0.0
+
+          self.save
+
+        end
+
+        def ensure_children_link
+
+          self.children_link = 1
+
+          if self.children.length > 0 and self.quantity > 0
+
+            # update from line_total
+            self.line_total = self.children.sum(:line_total)
+
+            # update unit_price since line_total is sum of children's line_total
+            self.unit_price = self.line_total / self.quantity
+
+            self.discount = self.children.sum(:discount)
+            self.line_total_after_discount = self.children.sum(:line_total_after_discount)
+            self.tax = self.children.sum(:tax)
+            self.line_total_with_tax = self.children.sum(:line_total_with_tax)
+
+          end
+
+          self.save
+
+        end
+
+        def is_children_linked?
+          self.children_link == 1
+        end
+
+        def add_ext_cal(cal)
+          if self.extended_calculators.nil?
+            res = { local: [], quotation: [] }
+          else
+            res = YAML.load(self.extended_calculators)
+          end
+
+          case cal
+          when Hash
+            ac = ExtendedCalculator.instance_from_hash(cal)
+          when ExtendedCalculator
+            ac = cal
+          else
+            raise ExtendedCalculator::ExtendedCalculatorException, "Unsupported calculator type '#{cal.class}'"
+          end
+
+          ac.owner = :quotation_item
+          ac.owner_id = self.id if not self.new_record?
+
+          res[:local] << ac
+
+          self.extended_calculators = YAML.dump(res)
+        end
+
+        def update_ext_cal(ecid, opts = {  })
+          if not self.extended_calculators.nil?
+            cal = YAML.load(self.extended_calculators)
+            cal[:local].each do |c|
+              if c.ecid == ecid
+                opts.each do |k,v|
+                  c.send("#{k}=", v)
+                end
+              end
+            end
+
+            cal[:quotation].each do |c|
+              if c.ecid == ecid
+                opts.each do |k,v|
+                  c.send("#{k}=",v)
+                end
+              end
+            end
+
+            self.extended_calculators = YAML.dump(cal)
+          end
+        end
+
+        def add_quotation_ext_cal(cal)
+
+          if self.extended_calculators.nil?
+            res = { local: [], quotation: [] }
+          else
+            res = YAML.load(self.extended_calculators)
+          end
+
+          case cal
+          when Hash
+            ac = ExtendedCalculator.instance_from_hash(cal)
+          when ExtendedCalculator
+            ac = cal
+          else
+            raise ExtendedCalculator::ExtendedCalculatorException, "Unsupported calculator type '#{cal.class}'"
+          end
+
+          res[:quotation] << ac
+
+          self.extended_calculators = YAML.dump(res)
+          
+        end
+
+        def ext_cals
+          if self.extended_calculators.nil?
+            []
+          else
+            YAML.load(self.extended_calculators)
+          end
+        end
+
+        def get_item_discount(input_field = nil)
+          if not_empty?(self.extended_calculators) 
+            cal = YAML.load(self.extended_calculators)
+            found = nil
+            cal[:local].each do |c|
+              if c.is_a?(Smerp::Quotation::DiscountCalculator)
+                if not_empty?(input_field) 
+                  if c.input_field.to_sym == input_field.to_sym
+                    found = c
+                    break
+                  end
+                else
+                  found = c
+                  break
+                end
+              end
+            end
+
+            found
+          else
+            nil
+          end
+        end
+
+        def get_qoutation_discount(input_field = nil)
+          if not_empty?(self.extended_calculators) 
+            cal = YAML.load(self.extended_calculators)
+            found = nil
+            cal[:quotation].each do |c|
+              if c.is_a?(Smerp::Quotation::DiscountCalculator)
+                if not_empty?(input_field) 
+                  if c.input_field.to_sym == input_field.to_sym
+                    found = c
+                    break
+                  end
+                else
+                  found = c
+                  break
+                end
+              end
+            end
+
+            found
+          else
+            nil
+          end
+        end
+
+        def get_item_tax
+          if not_empty?(self.extended_calculators) 
+            cal = YAML.load(self.extended_calculators)
+            found = nil
+            cal[:local].each do |c|
+              if c.is_a?(Smerp::Quotation::TaxCalculator)
+                found = c
+                break
+              end
+            end
+
+            if found.nil?
+              cal[:quotation].each do |c|
+                if c.is_a?(Smerp::Quotation::TaxCalculator)
+                  found = c
+                  break
+                end
+              end
+            end
+
+            found
+          else
+            nil
+          end
+          
+        end
+
+
+      end
+    end
+  end
+
+end

data/lib/smerp/quotation/ar_model/quotation_item_group.rb

@@ -0,0 +1,34 @@
+
+require 'acts_as_tree'
+
+module Smerp
+  module Quotation
+
+    module ArModel
+      class QuotationItemGroup < Ca::DataStore::Ar::Model
+        include ActsAsTree
+
+        acts_as_tree
+
+        has_many :quotation_items
+
+        belongs_to :quotation
+
+        after_save :update_parent
+
+        def update_parent
+          par = self.parent
+          if not par.nil?
+            par.group_total = par.children.sum(:group_total) + par.quotation_items.sum(:line_total)
+            par.group_discount = par.children.sum(:group_discount) + par.quotation_items.sum(:discount)
+
+            par.group_tax = par.children.sum(:group_tax) + par.quotation_items.sum(:tax)
+
+            par.save
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/smerp/quotation/ar_model/tax_category.rb

@@ -0,0 +1,34 @@
+
+
+module Smerp
+  module Quotation
+    module ArModel
+
+      class TaxCategory < Ca::DataStore::Ar::Model
+
+        validates_uniqueness_of :name
+        validates_uniqueness_of :display_code
+
+        belongs_to :extended_calculator
+        
+        state_machine initial: :active do
+
+          event :inactivate do
+            transition :active => :inactive
+          end
+
+          event :activate do
+            transition :inactive => :active
+          end
+
+          event :deprecate do
+            transition :inactive => :deprecated
+          end
+
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/smerp/quotation/calculators/discount_calculator.rb

@@ -0,0 +1,69 @@
+
+
+module Smerp
+  module Quotation
+    class DiscountCalculator
+      include ExtendedCalculator
+      include TR::CondUtils
+
+      include TeLogger::TeLogHelper
+      teLogger_tag :discountCal
+
+      DiscountedAmount = :discounted_amount
+      ValueAfterDiscount = :value_after_discount
+
+      def calculate(mdl)
+       
+        srcVal = mdl.send(@input_field)
+        if not_empty?(srcVal)
+
+          srcVal = srcVal.to_f
+
+          res = { input: @input_field, input_value: srcVal }
+          case @params
+          when Smerp::Common::FinUtils::Percent
+            res[DiscountedAmount] = srcVal * @params.rep_value
+          when Smerp::Common::FinUtils::RawValue
+            res[DiscountedAmount] = @params.rep_value
+          else
+            res[DiscountedAmount] = @params.to_f
+          end
+
+          res[ValueAfterDiscount] = srcVal - res[DiscountedAmount]
+
+          if not_empty?(@output_field)
+
+            case @output_field
+            when Array
+              @output_field.each do |of|
+                of.each do |f, v|
+                  mdl.send("#{f}=", res[v])
+                end
+              end
+            when Hash
+              @output_field.each do |f,v|
+                mdl.send("#{f}=", res[v])
+              end
+            when Symbol
+              mdl.send("#{@output_field}=", res[DiscountedAmount])
+            end
+
+            res[:output] = @output_field
+            mdl.recalculate
+          end
+
+          @result = res
+
+          trigger_listener(:after_calculation, mdl)
+
+          teLogger.debug "Discount calculation log : #{res}"
+
+          @result
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/smerp/quotation/calculators/round_up_calculator.rb

@@ -0,0 +1,33 @@
+
+
+module Smerp
+  module Quotation
+    class RoundUpCalculator
+      include ExtendedCalculator
+      include TR::CondUtils
+
+      include TeLogger::TeLogHelper
+      teLogger_tag :roundUpCal
+
+      def calculate(mdl)
+        srcVal = mdl.send(@input_field)
+        if not_empty?(srcVal) 
+
+          @result = srcVal.to_f.round_to_nearest(@params)  
+          teLogger.debug "Rounding field '#{@input_field}' (#{srcVal}) to nearest #{@params} is #{@result.inspect}"
+
+          if not_empty?(@output_field)
+            mdl.send("#{@output_field}=", @result.rounded_value)
+            mdl.recalculate
+          end
+
+          trigger_listener(:after_calculation, mdl)
+
+          @result
+
+        end
+      end
+
+    end
+  end
+end

data/lib/smerp/quotation/calculators/tax_calculator.rb

@@ -0,0 +1,76 @@
+
+
+module Smerp
+  module Quotation
+    class TaxCalculator
+      include ExtendedCalculator
+      include TR::CondUtils
+
+      include TeLogger::TeLogHelper
+      teLogger_tag :taxCal
+
+      attr_accessor :tax_category_id, :name, :code, :notes
+
+      TaxAmount = :tax_amount
+      ValueWithTax = :value_with_tax
+
+      def calculate(mdl)
+        
+        srcVal = mdl.send(@input_field)
+        if not_empty?(srcVal)
+
+          srcVal = srcVal.to_f
+
+          res = { input: @input_field, input_value: srcVal }
+          case @params
+          when Smerp::Common::FinUtils::Percent
+            res[TaxAmount] = srcVal * @params.rep_value
+          when Smerp::Common::FinUtils::RawValue
+            res[TaxAmount] = @params.rep_value
+          else
+            res[TaxAmount] = @params.to_f
+          end
+
+          res[ValueWithTax] = srcVal + res[TaxAmount]
+
+          if not_empty?(@output_field)
+
+            case @output_field
+            when Array
+              @output_field.each do |of|
+                of.each do |f, v|
+                  mdl.send("#{f}=", res[v])
+                end
+              end
+
+            when Hash
+              @output_field.each do |f,v|
+                mdl.send("#{f}=", res[v])
+              end
+
+            when Symbol
+              mdl.send("#{@output_field}=", res[ValueWithTax])
+
+            end
+
+            res[:output] = @output_field
+          end
+
+          teLogger.debug "Tax calculation log : #{res}"
+
+          res[:tax_category_id] = @tax_category_id
+          res[:name] = @name
+          res[:code] = @code
+          res[:notes] = @notes
+
+          @result = res
+          
+          trigger_listener(:after_calculation, mdl)
+
+          @result
+        end
+
+      end
+    end
+  end
+end