stockor 0.1.9 → 0.2

data/lib/skr/models/address.rb

@@ -85,7 +85,7 @@ module Skr
             ret << ', ' + postal_code.to_s unless postal_code.blank?
             include = [ *include ]
             if include.any?
-                ret << "\n" + include.map{ | field | self[ field ] }.join(' ')
+                ret << "\n" + include.map{ | field | self[ field ] }.join("\n")
             end
             ret
         end

data/lib/skr/models/bank_account.rb

@@ -0,0 +1,13 @@
+module Skr
+
+    class BankAccount < Model
+
+        has_code_identifier from: 'name'
+
+        belongs_to :gl_account, class_name: 'Skr::GlAccount', export: true
+
+        belongs_to :address,  class_name: 'Skr::Address',
+                   export: { writable: true }, dependent: :destroy
+    end
+
+end

data/lib/skr/models/business_entity.rb

@@ -26,6 +26,9 @@ module Skr
             self.terms ||= PaymentTerm.find_by_code(Skr.config.customer_terms_code)
         end
 
+        def get_form(type)
+            forms ? forms[type] : 'default'
+        end
     end
 
 end

data/lib/skr/models/customer.rb

@@ -21,7 +21,7 @@ module Skr
         # Updates the amount the customer owes, which is the sum of the amount unpaid on open invoices
         def update_balance!(*)
             update_attributes open_balance: invoices.open_for_customer(self)
-                                                    .with_details.sum('details.total')
+                                                    .with_details.sum('details.invoice_total')
         end
 
       private

data/lib/skr/models/customer_project.rb

@@ -0,0 +1,22 @@
+module Skr
+
+    class CustomerProject < Model
+        has_code_identifier from: 'name'
+
+        belongs_to :sku, export: true
+        belongs_to :customer, export: true
+
+        delegate_and_export :sku_code
+        delegate_and_export :customer_code
+
+        validates :sku, :customer, set: true
+
+        has_many :time_entries, inverse_of: :customer_project, export: true
+
+        scope :with_details, lambda { | *args |
+            compose_query_using_detail_view(view: 'skr_customer_project_details')
+        }, export: true
+
+    end
+
+end

data/lib/skr/models/gl_account.rb

@@ -10,7 +10,17 @@ module Skr
 
         is_immutable except: [:name, :is_active]
 
-        validates :name, :description, :presence => true
+        validates :name, :presence => true
+
+        # joins the gl_balances view which includes the
+        # branch_number and balance fields
+        scope :with_balances, lambda { | *args |
+            compose_query_using_detail_view(view: 'skr_gl_account_balances')
+        }, export: true
+
+        scope :with_combined_name, lambda {|*args|
+            select("*, number||' '||name as combined_name")
+        }, export: true
 
         # @!attribute description
         #   A short description of the GL Account
@@ -19,7 +29,7 @@ module Skr
         # with mandatory 4 characters + 2 char branch code
         validates :number, :presence => true, :numericality=>true, :length=>{ :is=>4 }
 
-        # @return [GlAccount] the default account for the key from {Skr::Core::Configuration.default_gl_accounts}
+        # @return [GlAccount] the default account for the key from {Skr::Configuration.default_gl_accounts}
         def self.default_for( lookup )
             number = Skr.config.default_gl_accounts[ lookup ]
             raise RuntimeError.new("Unkown GL default account lookup code: {lookup}") unless number
@@ -48,7 +58,7 @@ module Skr
 
         # @return [BigDecimal] the balance for a given period
         def balance_for( period, mask = self.account_mask )
-            GlPosting.matching( period, account_mask ).sum(:amount)
+            GlPosting.applying_to_period( period ).matching( account_mask ).sum(:amount)
         end
 
     end

data/lib/skr/models/gl_period.rb

@@ -8,6 +8,12 @@ module Skr
             attr = { year: Time.now.year, period: Time.now.month }
             GlPeriod.where( attr ).first || GlPeriod.create( attr )
         end
+
+        def self.is_date_locked?( date )
+            date && GlPeriod.select(:is_locked).where(
+                year: date.year, period: date.month, is_locked: true
+            ).first
+        end
     end
 
 end

data/lib/skr/models/gl_posting.rb

@@ -12,10 +12,13 @@ module Skr
         validates :amount,  numericality: true, presence: true
         validate  :ensure_accounting_validity, on: :create
 
-        scope :applying_to_period, ->(period){ where( '(period <= :period and year = :year) or (year < :year)',
-                                                      { period: period.period, year: period.year } ) }
-        scope :matching, ->(period, account_mask){
-            applying_to_period( period ).where('account_number like ?', account_mask )
+        scope :applying_to_period, -> (period) {
+            where( '(period <= :period and year = :year) or (year < :year)',
+                   { period: period.period, year: period.year } )
+        }
+
+        scope :matching, -> (account_mask) {
+            where('account_number like ?', account_mask )
         }
 
         def account=(acct)

data/lib/skr/models/gl_transaction.rb

@@ -1,4 +1,3 @@
-
 module Skr
 
     # A transaction is a record of a business event that has financial consequences.
@@ -20,12 +19,16 @@ module Skr
 
         is_immutable
 
-        # A Transaction must refer to another record, such as Invoice, Inventory Adjustment, or a Manual Posting.
+        # A Transaction must refer to another record,
+        # such as Invoice, Inventory Adjustment, or a Manual Posting.
         belongs_to :source, :polymorphic=>true
 
         # Each transaction belongs to an accounting period
         belongs_to :period, :class_name=>'Skr::GlPeriod', export: true
 
+        has_many :postings, class_name: 'Skr::GlPosting',
+                 inverse_of: :gl_transaction, export: { writable: true }
+
         has_many :credits, ->{ where({ is_debit: false }) }, class_name: 'Skr::GlPosting',
                  extend: Concerns::GlTran::Postings,
                  inverse_of: :gl_transaction, export: { writable: true }
@@ -40,17 +43,22 @@ module Skr
         validates :source, :period,  :set=>true
         validates :description,      :presence=>true
 
+        scope :with_details, lambda { | acct = nil |
+            query = compose_query_using_detail_view(view: 'skr_gl_transaction_details',
+                                                    join_to: :gl_transaction_id)
+            acct.blank? ? query : query.joins(:postings).merge( GlPosting.matching(acct) )
+        }, export: true
 
         # Add a debit/credit pair to the transaction with amount
         # @param amount [BigDecimal] the amount to apply to each posting
         # @param debit [GlAccount]
         # @param credit [GlAccount]
         def add_posting( amount: nil, debit: nil, credit: nil )
-            Skr::Core.logger.debug "GlTransaction add_posting #{debit} : #{credit}"
+            Lanes.logger.debug "GlTransaction add_posting #{debit} : #{credit}"
             self.credits.build( location: @location, is_debit: false,
-              account: credit, amount: amount )
+                                account: credit, amount: amount )
             self.debits.build(  location: @location, is_debit: true,
-              account: debit,  amount: amount * -1 )
+                                account: debit,  amount: amount * -1 )
         end
 
         # Passes the location onto the postings.
@@ -65,7 +73,7 @@ module Skr
         # @yield [GlPosting] each posting associated with the Transaction
         def each_posting
             self.credits.each{ |posting| yield posting }
-            self.debits.each{ |posting| yield posting }
+            self.debits.each{  |posting| yield posting }
         end
 
         # @return [GlTransaction] the current transaction that's in progress
@@ -82,7 +90,7 @@ module Skr
             Thread.current[:gl_transaction] ||= []
             glt = GlTransaction.new( attributes )
             Thread.current[:gl_transaction].push( glt )
-            Skr::Core.logger.debug "B4 GlTransaction"
+            Lanes.logger.debug "B4 GlTransaction"
             results = yield glt
             Thread.current[:gl_transaction].pop
             if results
@@ -90,7 +98,7 @@ module Skr
                     glt.assign_attributes( results[:attributes] )
                 end
                 glt._save_recorded
-                Skr::Core.logger.debug "AF GlTransaction new=#{glt.new_record?} #{glt.errors.full_messages}"
+                Lanes.logger.debug "AF GlTransaction new=#{glt.new_record?} #{glt.errors.full_messages}"
             end
             return glt
         end
@@ -101,16 +109,13 @@ module Skr
         # @param credit  [GlAccount]
         # @param options  [Hash] options to pass to the [GlTransaction] if one is created
         def self.push_or_save( owner: nil, amount: nil, debit:nil, credit:nil, options:{} )
-            if glt = self.current # we push
+            if (glt = self.current) # we push
                 glt.add_posting( amount: amount, debit: debit, credit: credit )
             else
-                options.merge!({
-                    source: owner,
-                    location: options[:location] || owner.location
-                })
+                options.merge!(source: owner, location: options[:location] || owner.location)
                 glt = GlTransaction.new( options )
                 glt.add_posting( amount: amount, debit: debit, credit: credit )
-                glt.save
+                glt.save!
             end
             glt
         end
@@ -152,24 +157,5 @@ module Skr
             self.period ||= GlPeriod.current
         end
 
-        # def ensure_postings_exist
-        #     if self.new_record? and self.postings.empty?
-        #         2.times { self.postings.build }
-        #     end
-        # end
-
     end
 end
-
-__END__
-
-# export_join_tables :details
-# export_scope :with_details_for, lambda { | acct |
-#     acct = acct.gsub(/\D/,'') + '%'
-#     cs = "case when details.debit_account_number like '#{acct}' then details.debit_amount " +
-#          "when details.credit_account_number like '#{acct}' then details.credit_amount else 0 end"
-#     window = "#{cs} as amount, sum(#{cs}) over (order by created_at) as balance"
-#     joins('join gl_transaction_details as details on details.gl_transaction_id = gl_transactions.id')
-#         .select("gl_transactions.*, details.*, #{window}")
-#         .where("debit_account_number like :acct or credit_account_number like :acct", acct: acct)
-# }

data/lib/skr/models/ia_line.rb

@@ -86,7 +86,7 @@ module Skr
                 raise "Unable to apply line, either not approved or previously applied"
             end
             set_cost_from_sku_loc
-            Core.logger.debug( "Adjusting #{self.qty} #{combined_uom} of #{sku_code} into stock")
+            Lanes.logger.debug( "Adjusting #{self.qty} #{combined_uom} of #{sku_code} into stock")
             self.build_sku_tran({
                 :origin=>self, :qty => self.qty, :sku_loc=>self.sku_loc,
                 origin_description: "IA #{self.inventory_adjustment.visible_id}:#{self.sku.code}",

data/lib/skr/models/inv_line.rb

@@ -3,27 +3,31 @@ module Skr
     class InvLine < Skr::Model
 
         acts_as_uom
-        is_immutable
+
         is_sku_loc_line parent: "invoice"
 
         locked_fields :qty, :sku_loc_id, :so_line
         belongs_to :invoice
 
         belongs_to :so_line, export: true
+        belongs_to :time_entry, export: true
         belongs_to :pt_line, :inverse_of=>:inv_line, export: true
         belongs_to :sku_loc, export: true
 
         has_one :sku, :through => :sku_loc, export: true
         has_one :location, :through => :sku_loc
-        has_one :sku_tran, :as=>:origin
 
-        validates :sku_loc,  set: true
+        has_many :sku_trans, :as=>:origin, autosave: true
+        has_many :uom_choices, :through => :sku, :source => :uoms, export: true
 
+        validates :sku_loc,  set: true
         validates :price, :qty, :numericality=>true
         validates :uom_code, :sku_code, :description, :uom_size, :presence=>true
+        validate  :ensure_unlocked
 
         before_validation :set_defaults
-        before_save :adjust_inventory
+        before_save :perform_adjustments
+        before_destroy :prevent_destroy
 
         scope :with_details, lambda { |should_use=true |
             compose_query_using_detail_view( view: 'inv_details', join_to: 'inv_line_id' ) if should_use
@@ -36,15 +40,24 @@ module Skr
             .group('s.code,s.description, s.id')
         }, export: true
 
+        def total
+            (qty||0) * (price||0)
+        end
+
+        def ensure_unlocked
+            if invoice.is_locked?
+                self.errors.add(:invoice_date, "invoice date falls on a locked GL Period")
+            end
+        end
 
-        private
+      private
 
         def set_defaults
 #           puts "set_defaults #{self}"
             line = [ self.pt_line, self.so_line ].detect{ |l| ! l.blank? }
             if line
                 self.uom         = line.uom if self.uom.blank?
-                self.sku_code    ||= line.sku_code
+                self.sku_code    = line.sku_code
                 self.description ||= line.description
                 self.sku_loc     ||= line.sku_loc
                 self.qty         ||= line.qty
@@ -63,28 +76,33 @@ module Skr
             true
         end
 
-        def adjust_inventory
+        def perform_adjustments
             debit  = self.sku.gl_asset_account
             credit = self.invoice.customer.gl_receivables_account
+            old_extended_price = self.price_was && self.qty_was ?
+                                     self.price_was * self.qty_was : BigDecimal.new(0)
+            price_change = self.extended_price - old_extended_price
+
             if self.sku.does_track_inventory?
-                self.build_sku_tran({
-                    origin: self, qty: self.qty*-1, sku_loc: self.sku_loc, uom: self.uom,
-                    mac: 0, cost: self.extended_price,
+                changed_qty = self.qty - (qty_was || 0)
+                self.sku_trans.build(
+                    origin: self, qty: changed_qty * -1, sku_loc: self.sku_loc, uom: self.uom,
+                    mac: 0, cost: price_change,
                     origin_description: "INV #{self.invoice.visible_id}:#{self.sku.code}",
                     debit_gl_account:  debit, credit_gl_account: credit
-                })
+                )
             else
                 GlTransaction.push_or_save(
-                  owner: self, amount: self.total,
+                  owner: self, amount: price_change,
                   debit: debit, credit: credit
                 )
             end
             true
         end
 
-
-
+        def prevent_destroy
+            errors.add(:base, "Can not destroy #{self.class.model_name}, only create/modify is allowed" )
+        end
     end
 
-
 end # Skr module

data/lib/skr/models/invoice.rb

@@ -33,35 +33,37 @@ module Skr
         has_additional_events :amount_paid_change
 
         belongs_to :sales_order,      export: true
+        belongs_to :customer_project, export: true
         belongs_to :customer,         export: true
         belongs_to :location,         export: true
+        belongs_to :pick_ticket,      inverse_of: :invoice,           export: true
         belongs_to :terms,            class_name: 'Skr::PaymentTerm', export: true
-        belongs_to :pick_ticket,      inverse_of: :invoice,      export: true
         belongs_to :billing_address,  class_name: 'Skr::Address',     export: { writable: true }
         belongs_to :shipping_address, class_name: 'Skr::Address',     export: { writable: true }
 
         has_many :gl_transactions, :as=>:source
 
-        has_many :lines, -> { order(:position) }, class_name: 'Skr::InvLine', inverse_of: :invoice,
-                                                  extend: Concerns::INV::Lines, export: { writable: true }
+        has_many :lines, -> { order(:position) },
+                 class_name: 'Skr::InvLine', inverse_of: :invoice,
+                 extend: Concerns::INV::Lines, export: { writable: true }
 
         before_save :maybe_mark_paid
 
         before_validation :set_defaults, on: :create
 
         validates :customer, :location, set: true
-        validate  :ensure_location_matches_so
+        validate  :ensure_unlocked, :ensure_location_matches_so
 
         scope :open_for_customer, lambda{ | customer |
-            where([ "customer_id=? and state != 'paid'", customer.is_a?(Customer) ? customer.id : customer ])
+            where(state: :open, customer_id: customer.is_a?(Customer) ? customer.id : customer)
         }, export: true
 
         scope :with_details, lambda { |should_use=true |
-            compose_query_using_detail_view( view: 'inv_details', join_to: 'invoice_id' )
+            compose_query_using_detail_view( view: 'skr_inv_details', join_to: 'invoice_id' )
         }, export: true
 
         enum state: {
-            open:     0,
+            open:     1,
             paid:     5,
             partial: 10
         }
@@ -82,7 +84,8 @@ module Skr
 
         def initialize(attributes = {})
             super
-            self.invoice_date = Date.today
+            # date must be set, otherwise things like terms that are based off of it fail
+            self.invoice_date ||= Date.today
         end
 
         # @return [BigDecimal] total - amount_paid
@@ -95,37 +98,44 @@ module Skr
             unpaid_amount <= 0
         end
 
+        # @return [DateTime] when the invoice is due
+        def due_date
+            self.terms.due_date_from(invoice_date)
+        end
+
+        def is_locked?
+            GlPeriod.is_date_locked?(self.invoice_date)
+        end
+
         private
 
         # attributes for GlTransaction
         def attributes_for_gl_transaction
-            {   location: location, source: self,
-                description: "INV #{self.visible_id}" }
+            { location: location, source: self,
+              description: "INV #{self.visible_id}" }
         end
 
         # set the state if the amount_paid was changed
         def maybe_mark_paid
             return unless amount_paid_changed?
             if self.fully_paid? && self.may_mark_paid?
-                self.state_event = 'mark_paid'
+                self.mark_paid
             elsif self.amount_paid > 0 && self.may_mark_partial?
-                self.state_event = 'mark_partial'
+                self.mark_partial
             end
         end
 
         def apply_balances
             return unless amount_paid_changed?
             change = amount_paid - amount_paid_was
-
-            Skr::Core.logger.debug "Applying payment #{amount_paid} changed: #{change}"
-
+            Lanes.logger.debug "Applying payment #{amount_paid} changed: #{change}"
             return if change.zero?
-
             GlTransaction.push_or_save(
               owner: self, amount: change,
-              debit: customer.gl_receivables_account, credit: GlAccount.default_for(:deposit_holding)
+              debit: customer.gl_receivables_account,
+              credit: GlAccount.default_for(:deposit_holding)
             )
-            fire_event( :amount_paid_change )
+            fire_pubsub_event( :amount_paid_change )
             true
         end
 
@@ -139,20 +149,37 @@ module Skr
 
             if sales_order
                 self.terms          ||= sales_order.terms
+                self.form           ||= sales_order.form
                 self.customer         = sales_order.customer
                 self.po_num           = sales_order.po_num if self.po_num.blank?
                 self.billing_address  = sales_order.billing_address   if self.billing_address.blank?
                 self.shipping_address = sales_order.shipping_address  if self.shipping_address.blank?
-                self.options.merge!(sales_order.options)
+                if self.options && sales_order.options
+                    self.options.merge!(sales_order.options)
+                else
+                    self.options = sales_order.options
+                end
+            end
+
+            if customer_project
+                self.customer = customer_project.customer
+                self.po_num = customer_project.po_num if self.po_num.blank?
             end
 
             if customer
-                self.billing_address = customer.billing_address   if self.billing_address.blank?
+                self.form           ||= customer.get_form('invoice')
+                self.billing_address  = customer.billing_address   if self.billing_address.blank?
                 self.shipping_address = customer.shipping_address if self.shipping_address.blank?
             end
 
         end
 
+        def ensure_unlocked
+            if is_locked?
+                self.errors.add(:invoice_date, "falls on a locked GL Period")
+            end
+        end
+
         def ensure_location_matches_so
             if sales_order && location != sales_order.location
                 self.errors.add(:location, "#{location.code} must match location that order was taken on (#{sales_order.location.code})")

data/lib/skr/models/location.rb

@@ -5,6 +5,8 @@ module Skr
 
         has_code_identifier :from=>'name'
 
+        mount_uploader :logo, Lanes::Concerns::ImageUploader
+
         belongs_to :address, export: { writable: true }
 
         has_many :sku_locs
@@ -15,7 +17,11 @@ module Skr
 
         before_validation :set_defaults, :on=>:create
 
-        # @return [Location] the location that's specified by {Skr::Core::Configuration#default_location_code}
+        def get_logo
+            self.logo.present? ? self.logo : Lanes::SystemSettings.config.logo
+        end
+
+        # @return [Location] the location that's specified by {Skr::Configuration#default_location_code}
         def self.default
             Location.find_by_code( Skr.config.default_location_code )
         end

data/lib/skr/models/payment.rb

@@ -0,0 +1,49 @@
+module Skr
+
+    class Payment < Model
+        has_visible_id
+        has_random_hash_code
+        has_gl_transaction
+
+        belongs_to :category,     class_name: 'Skr::PaymentCategory', export: true
+        belongs_to :vendor,       class_name: 'Skr::Vendor',          export: true
+        belongs_to :bank_account, class_name: 'Skr::BankAccount',     export: true
+        belongs_to :location,     class_name: 'Skr::Location',        export: true
+
+        validates :name, :amount, :category, :bank_account, presence: true
+
+        has_one :gl_transaction, class_name: 'Skr::GlTransaction', as: :source
+
+        before_validation :set_defaults, on: :create
+
+        after_save :apply_transaction
+
+        def latex_template_variables
+            { 'position' => :absolute }
+        end
+
+      private
+
+        def attributes_for_gl_transaction
+            { location: location, source: self,
+              description: "Payment #{self.visible_id}" }
+        end
+
+        def apply_transaction
+            credit = vendor ? vendor.gl_payables_account : category.gl_account
+
+            GlTransaction.push_or_save(
+                owner: self, amount: amount,
+                debit: bank_account.gl_account,
+                credit: credit
+            )
+        end
+
+        def set_defaults
+            self.location     ||= Location.default
+            self.date         ||= Date.today
+            self.check_number ||= SequentialId.next_for("Pmnt-#{bank_account.id}")
+        end
+
+    end
+end

data/lib/skr/models/payment_category.rb

@@ -0,0 +1,11 @@
+module Skr
+
+    class PaymentCategory < Model
+
+        has_code_identifier from: 'name'
+
+        belongs_to :gl_account, class_name: 'Skr::GlAccount', export: true
+
+    end
+
+end

data/lib/skr/models/payment_term.rb

@@ -6,7 +6,7 @@ module Skr
         has_code_identifier
 
         def discount
-            @discount_percnum ||= Core::Numbers::PercNum.new( read_attribute('discount_amount') )
+            @discount_percnum ||= Numbers::PercNum.new( read_attribute('discount_amount') )
         end
 
         def discount_amount=(value)

data/lib/skr/models/por_line.rb

@@ -35,7 +35,7 @@ module Skr
         private
 
         def adjust_inventory
-            Core.logger.debug( "Receiving #{self.ea_qty} into stock" )
+            logger.debug( "Receiving #{self.ea_qty} into stock" )
             tran = self.sku_trans.build({
                 origin: self, qty: self.qty,
                 sku_loc: po_line.sku_loc,

data/lib/skr/models/pt_line.rb

@@ -61,7 +61,7 @@ module Skr
             self.sku_loc     ||= so_line.sku_loc
             self.bin         ||= sku_loc.bin
             self.price       ||= so_line.price
-            self.sku_code    = sku_loc.sku.code    if self.sku_code.blank?
+            self.sku_code    = sku_loc.sku.code
             self.description = so_line.description if self.description.blank?
             self.uom         = so_line.uom         if self.uom.blank?
             true