cats_core 1.5.2 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f44f88a61efb78a98b957e1125a822e36a3fba743e600f28da163dcf3ee8e1fd
-  data.tar.gz: ba63704a7b079b931187ca2ea007202d57e94b3b4bba19c133dd9028873cae8d
+  metadata.gz: e9a6ea1b862a6804a3e215898c7aac9966ffedbdf7aa3c8d9661f9356c4b8a24
+  data.tar.gz: f08e17d946b62d02d148cffbe97ab52c9b1f113245d4dffca6f5d67256ec7ea0
 SHA512:
-  metadata.gz: 8dbba69e6545334259ca98493c13a2571754ff2d1eccf9ef6178e7a38105c319c3345106683415dc1654fa35c26d03df04ce7a072b235aa8e0e4c7f2afafd390
-  data.tar.gz: 1e827e9172351fca12b42fc2910a639b2cb0556e64b1608bee56704892de22f39a897c03b0688a0cc1596b425c8ed5e41bbe9a894e20a3536f801b8d4e91bb2c
+  metadata.gz: ea2045f6a7a7954a4157952747c932e096f5df6e8ab2a56e888ca1f656a85eb7bd08a572ad0f15a05b53b0defc51354c27755be960c69c4c0ec49b232ad9b5db
+  data.tar.gz: d91d382689b7abab6221e64457123334bc93bc0357ffdf6eb28e71466d46183ba3aeab2b0d01b24abb0184a7b01b06ae5d0e2331220b710b3a193ac751061ad6

data/app/controllers/cats/core/commodities_controller.rb

@@ -5,7 +5,7 @@ module Cats
 
       def index
         super do
-          Commodity.all.includes({ project: { source: :commodity_category } }, :unit_of_measure)
+          Commodity.all.includes({ project: { source: :commodity_category } }, :unit_of_measure, :package_unit)
         end
       end
 
@@ -18,7 +18,7 @@ module Cats
       end
 
       def filter
-        query = Commodity.includes(:project, :unit_of_measure).ransack(params[:q])
+        query = Commodity.includes(:project, :unit_of_measure, :package_unit).ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 

data/app/controllers/cats/core/dispatch_authorizations_controller.rb

@@ -5,7 +5,7 @@ module Cats
 
       def index
         super do
-          DispatchAuthorization.includes(:dispatch, :store, :authorized_by).where(dispatch_id: params[:id])
+          DispatchAuthorization.includes(:dispatch, :store, :authorized_by, :unit).where(dispatch_id: params[:id])
         end
       end
 
@@ -21,7 +21,7 @@ module Cats
         storekeeper = User.find(params[:id])
         stores = storekeeper.stores
         authorizations = DispatchAuthorization.joins(:dispatch)
-                                              .includes(:dispatch, :store, :authorized_by)
+                                              .includes(:dispatch, :store, :authorized_by, :unit)
                                               .where(store: stores, dispatch: { dispatch_status: Dispatch::APPROVED })
         render json: { success: true, data: serialize(authorizations) }
       end
@@ -29,7 +29,7 @@ module Cats
       private
 
       def model_params
-        params.require(:payload).permit(:dispatch_id, :store_id, :quantity, :status, :authorized_by_id)
+        params.require(:payload).permit(:dispatch_id, :store_id, :quantity, :unit_id, :status, :authorized_by_id)
       end
     end
   end

data/app/controllers/cats/core/dispatch_transactions_controller.rb

@@ -5,7 +5,7 @@ module Cats
 
       def index
         super do
-          DispatchTransaction.includes(:source).where(dispatch_authorization_id: params[:id])
+          DispatchTransaction.includes(:source, :unit).where(dispatch_authorization_id: params[:id])
         end
       end
 
@@ -37,7 +37,7 @@ module Cats
       private
 
       def model_params
-        params.require(:payload).permit(:source_id, :dispatch_authorization_id, :transaction_date, :quantity)
+        params.require(:payload).permit(:source_id, :dispatch_authorization_id, :transaction_date, :quantity, :unit_id)
       end
     end
   end

data/app/controllers/cats/core/lost_commodities_controller.rb

@@ -5,12 +5,12 @@ module Cats
 
       def index
         super do
-          LostCommodity.where(receipt_authorization_id: params[:id])
+          LostCommodity.includes(:unit).where(receipt_authorization_id: params[:id])
         end
       end
 
       def model_params
-        params.require(:payload).permit(:receipt_authorization_id, :quantity, :remark)
+        params.require(:payload).permit(:receipt_authorization_id, :quantity, :unit_id, :remark)
       end
     end
   end

data/app/controllers/cats/core/receipt_authorizations_controller.rb

@@ -7,7 +7,7 @@ module Cats
 
       def index
         super do
-          ReceiptAuthorization.includes(:dispatch, :store, :authorized_by).where(dispatch_id: params[:id])
+          ReceiptAuthorization.includes(:dispatch, :store, :authorized_by, :unit).where(dispatch_id: params[:id])
         end
       end
 
@@ -40,7 +40,7 @@ module Cats
         storekeeper = User.find(params[:id])
         status = params[:status]
         stores = storekeeper.stores
-        authorizations = ReceiptAuthorization.includes(:dispatch, :store, :authorized_by)
+        authorizations = ReceiptAuthorization.includes(:dispatch, :store, :authorized_by, :unit)
                                              .where(store: stores, status: status)
         render json: { success: true, data: serialize(authorizations) }
       end
@@ -48,7 +48,8 @@ module Cats
       private
 
       def model_params
-        params.require(:payload).permit(:dispatch_id, :store_id, :quantity, :remark, :status, :authorized_by_id)
+        params.require(:payload).permit(:dispatch_id, :store_id, :quantity, :unit_id, :remark, :status,
+                                        :authorized_by_id)
       end
 
       def driver_confirm_params

data/app/controllers/cats/core/receipt_transactions_controller.rb

@@ -5,7 +5,7 @@ module Cats
 
       def index
         super do
-          ReceiptTransaction.includes(:destination, { receipt_authorization: :dispatch })
+          ReceiptTransaction.includes(:destination, { receipt_authorization: :dispatch }, :unit)
                             .where(receipt_authorization_id: params[:id])
         end
       end
@@ -18,7 +18,8 @@ module Cats
       private
 
       def model_params
-        params.require(:payload).permit(:receipt_authorization_id, :destination_id, :transaction_date, :quantity)
+        params.require(:payload).permit(:receipt_authorization_id, :destination_id, :transaction_date, :quantity,
+                                        :unit_id)
       end
     end
   end

data/app/controllers/cats/core/receipts_controller.rb

@@ -5,7 +5,7 @@ module Cats
 
       def index
         super do
-          Receipt.where(receipt_authorization_id: params[:id])
+          Receipt.includes(:unit).where(receipt_authorization_id: params[:id])
         end
       end
 
@@ -13,7 +13,7 @@ module Cats
 
       def model_params
         params.require(:payload).permit(:receipt_authorization_id, :commodity_status, :commodity_grade, :quantity,
-                                        :remark)
+                                        :unit_id, :remark)
       end
     end
   end

data/app/controllers/cats/core/stacks_controller.rb

@@ -5,12 +5,12 @@ module Cats
 
       def index
         super do
-          Stack.includes(:commodity).where(store_id: params[:id])
+          Stack.includes(:commodity, :unit).where(store_id: params[:id])
         end
       end
 
       def filter
-        query = Stack.includes(:commodity).where(store_id: params[:id]).ransack(params[:q])
+        query = Stack.includes(:commodity, :unit).where(store_id: params[:id]).ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 
@@ -38,7 +38,7 @@ module Cats
 
       def model_params
         params.require(:payload).permit(:code, :length, :width, :height, :start_x, :start_y, :commodity_id, :store_id,
-                                        :commodity_status, :stack_status, :quantity)
+                                        :commodity_status, :stack_status, :quantity, :unit_id)
       end
     end
   end

data/app/models/cats/core/application_setting.rb

@@ -0,0 +1,10 @@
+module Cats
+  module Core
+    class ApplicationSetting < ApplicationRecord
+      belongs_to :application_module
+
+      validates :key, presence: true, uniqueness: true
+      validates :value, presence: true
+    end
+  end
+end

data/app/models/cats/core/authorization.rb

@@ -3,6 +3,7 @@ module Cats
     class Authorization < ApplicationRecord
       self.abstract_class = true
       after_initialize :set_status
+      before_validation :set_unit
 
       # Authorization statuses
       AUTHORIZED = 'Authorized'.freeze
@@ -11,6 +12,7 @@ module Cats
 
       belongs_to :dispatch
       belongs_to :store
+      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
       belongs_to :authorized_by, class_name: 'Cats::Core::User'
 
       validates :quantity, presence: true, numericality: { greater_than: 0 }
@@ -23,6 +25,15 @@ module Cats
       delegate(:dispatch_status, to: :dispatch)
       delegate(:plate_no, to: :dispatch)
       delegate(:driver_name, to: :dispatch)
+      delegate(:abbreviation, to: :unit, prefix: true)
+
+      def set_unit
+        return if unit
+
+        return unless dispatch
+
+        self.unit = dispatch.unit
+      end
 
       def validate_dispatch_status
         return unless dispatch
@@ -52,8 +63,9 @@ module Cats
             transactions.each(&:commit)
             self.status = CONFIRMED
             save!
+            reload
             if dispatch.all_authorizations_confirmed?
-              dispatch.generate_pin
+              Util.generate_pin(dispatch)
               dispatch.quantity = dispatch.dispatch_transactions.sum(:quantity)
               dispatch.dispatch_status = Dispatch::READY_TO_START
               dispatch.save!
@@ -70,17 +82,11 @@ module Cats
           self.received_quantity = total_received
           self.status = CONFIRMED
           save!
-          generate_pin
+          Util.generate_pin(self)
         end
         self
       end
 
-      def generate_pin
-        pin = SecureRandom.hex(10)
-        self.auth_details = { pin: pin, active: true, expires_at: DateTime.now + 1.hour }
-        save!
-      end
-
       private
 
       def set_status

data/app/models/cats/core/commodity.rb

@@ -44,6 +44,7 @@ module Cats
 
       belongs_to :unit_of_measure
       belongs_to :project
+      belongs_to :package_unit, class_name: 'Cats::Core::UnitOfMeasure', optional: true
 
       validates :best_use_before, presence: true
       validates :batch_no, presence: true, uniqueness: true
@@ -56,6 +57,9 @@ module Cats
 
       delegate(:abbreviation, to: :unit_of_measure, prefix: 'unit')
       delegate(:code, to: :project, prefix: true)
+      delegate(:abbreviation, to: :package_unit, prefix: true, allow_nil: true)
+
+      alias_attribute :unit, :unit_of_measure
 
       def name
         # For this to be efficient, our query should use includes like
@@ -86,6 +90,7 @@ module Cats
             store: store,
             commodity: self,
             quantity: quantity,
+            unit: unit,
             commodity_status: GOOD,
             stack_status: Stack::ALLOCATED,
             length: 100,
@@ -98,6 +103,11 @@ module Cats
         end
         result
       end
+
+      def requested_quantity
+        requests = RhnRequest.where(commodity: self)
+        UnitConversion.harmonized_total(requests, unit_of_measure)
+      end
     end
   end
 end

data/app/models/cats/core/dispatch.rb

@@ -35,10 +35,6 @@ module Cats
         dispatch_plan_item.destination.name
       end
 
-      def authorized_quantity
-        dispatch_authorizations.sum(:quantity)
-      end
-
       def validate_dispatch_plan_status
         return unless dispatch_plan_item
 
@@ -52,16 +48,9 @@ module Cats
         # Check if dispatch has authorizations
         raise(StandardError, 'Dispatch has no authorizations.') unless dispatch_authorizations.count.positive?
 
-        dispatches = Dispatch.where(dispatch_plan_item: dispatch_plan_item)
-        authorized = dispatches.inject(0) do |result, dispatch|
-          result += dispatch.authorized_quantity
-          result
-        end
-        diff = authorized - dispatch_plan_item.quantity
-        error = "Total authorized quantity exceeds allocated quantity (Extra = #{diff})."
-        raise(StandardError, error) if diff.positive?
-
+        dispatch_total = UnitConversion.harmonized_total(dispatch_authorizations, unit)
         self.dispatch_status = APPROVED
+        self.quantity = dispatch_total
         save!
       end
 
@@ -86,6 +75,7 @@ module Cats
           dispatch: self,
           store: store,
           quantity: quantity,
+          unit: unit,
           received_quantity: 0,
           status: Authorization::AUTHORIZED,
           authorized_by: authorized_by
@@ -128,12 +118,6 @@ module Cats
           }
         end
       end
-
-      def generate_pin
-        pin = SecureRandom.hex(10)
-        self.auth_details = { pin: pin, active: true, expires_at: DateTime.now + 1.hour }
-        save!
-      end
     end
   end
 end

data/app/models/cats/core/dispatch_authorization.rb

@@ -3,11 +3,24 @@ module Cats
     class DispatchAuthorization < Authorization
       has_many :dispatch_transactions
 
+      validate :validate_quantity
+
       def validate_dispatch_status
         return unless dispatch
 
         errors.add(:dispatch, 'is not in draft state.') unless dispatch.dispatch_status == Dispatch::DRAFT
       end
+
+      def validate_quantity
+        return unless dispatch && quantity && unit
+
+        authorizations = DispatchAuthorization.joins(:dispatch).where(
+          dispatch: { dispatch_plan_item_id: dispatch.dispatch_plan_item_id }
+        )
+        quantity_attribs = %w[dispatch_plan_item quantity]
+        unit_attribs = %w[dispatch_plan_item unit]
+        ValidationUtil.validate_quantity(self, 'dispatch', authorizations, 'allocated', quantity_attribs, unit_attribs)
+      end
     end
   end
 end

data/app/models/cats/core/dispatch_plan.rb

@@ -54,7 +54,9 @@ module Cats
       # A method which returns the total quantity in the dispatch plan
       # based on dispatch plan item quantities.
       def quantity
-        dispatch_plan_items.sum(:quantity)
+        raise(StandardError, 'Dispatchable must be RHN request.') unless dispatchable.instance_of?(RhnRequest)
+
+        UnitConversion.harmonized_total(dispatch_plan_items, dispatchable.unit)
       end
 
       def region

data/app/models/cats/core/dispatch_plan_item.rb

@@ -58,8 +58,8 @@ module Cats
           )
         end
 
-        total_src = source_auth.sum(&:quantity)
-        total_dest = dest_auth.sum(&:quantity)
+        total_src = UnitConversion.harmonized_total(source_auth, unit)
+        total_dest = UnitConversion.harmonized_total(dest_auth, unit)
 
         if source_auth.count == count
           validate_quantity(total_src, SOURCE_AUTHORIZED)
@@ -81,9 +81,10 @@ module Cats
 
         diff = self.quantity - quantity
         desc = type.split(' ')[0].downcase
+        amount = "#{diff} #{unit.abbreviation}"
         raise(
           StandardError,
-          "Authorized #{desc} quantity is not the same as plan item quantity (#{diff} unaccounted for)."
+          "Authorized #{desc} quantity is not the same as plan item quantity (#{amount} unaccounted for)."
         )
       end
     end

data/app/models/cats/core/dispatch_transaction.rb

@@ -1,6 +1,8 @@
 module Cats
   module Core
     class DispatchTransaction < Transaction
+      before_validation :set_unit
+
       belongs_to :source, class_name: 'Cats::Core::Stack'
       belongs_to :dispatch_authorization
 
@@ -10,9 +12,17 @@ module Cats
 
       delegate(:code, to: :source, prefix: true)
 
+      def set_unit
+        return if unit
+
+        return unless dispatch_authorization
+
+        self.unit = dispatch_authorization.unit
+      end
+
       def commit
         Transaction.transaction do
-          source.quantity -= quantity
+          source.quantity -= UnitConversion.convert(unit, source.unit, quantity)
           source.save!
 
           self.status = COMMITTED
@@ -30,19 +40,22 @@ module Cats
       def validate_source_quantity
         return unless quantity && source
 
-        total = DispatchTransaction.where(status: DRAFT, source: source).sum(:quantity)
-        diff = quantity - (source.quantity - total)
-        diff -= quantity_was if quantity_was
-        errors.add(:quantity, "exceeds source quantity by #{diff}") if diff.positive?
+        total = UnitConversion.convert(source.unit, unit, source.quantity)
+        transactions = DispatchTransaction.where(status: DRAFT, source: source)
+        used = UnitConversion.harmonized_total(transactions, unit)
+        used -= quantity_was if quantity_was
+
+        remaining = total - used
+        return unless quantity > remaining
+
+        errors.add(:quantity, "exceeds source quantity. Maximum allowed is #{remaining} #{unit.abbreviation}")
       end
 
       def validate_authorized_quantity
-        return unless quantity && dispatch_authorization
+        return unless quantity && unit && dispatch_authorization
 
-        total = DispatchTransaction.where(dispatch_authorization: dispatch_authorization).sum(:quantity)
-        diff = dispatch_authorization.quantity - total
-        diff += quantity_was if quantity_was
-        errors.add(:quantity, "exceeds authorized quantity (Max. = #{diff}).") if quantity > diff
+        transactions = DispatchTransaction.where(dispatch_authorization: dispatch_authorization)
+        ValidationUtil.validate_quantity(self, 'dispatch_authorization', transactions, 'authorized')
       end
 
       def skip_quantity_validation

data/app/models/cats/core/hub_authorization.rb

@@ -1,6 +1,8 @@
 module Cats
   module Core
     class HubAuthorization < ApplicationRecord
+      before_validation :set_unit
+
       SOURCE = 'Source'.freeze
       DESTINATION = 'Destination'.freeze
       AUTHORIZATION_TYPES = [SOURCE, DESTINATION].freeze
@@ -8,6 +10,7 @@ module Cats
       belongs_to :dispatch_plan_item, optional: true
       belongs_to :store
       belongs_to :authorized_by, class_name: 'Cats::Core::User'
+      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
 
       validates :quantity, :authorization_type, presence: true
       validates :quantity, numericality: { greater_than: 0 }
@@ -17,21 +20,24 @@ module Cats
       delegate(:plan_reference_no, to: :dispatch_plan_item)
       delegate(:full_name, to: :authorized_by, prefix: true)
       delegate(:name, to: :store, prefix: true)
+      delegate(:abbreviation, to: :unit, prefix: true)
 
-      def validate_quantity
-        return unless quantity
+      def set_unit
+        return if unit
 
         return unless dispatch_plan_item
 
-        total = dispatch_plan_item.quantity
-        used = HubAuthorization.where(
+        self.unit = dispatch_plan_item.unit
+      end
+
+      def validate_quantity
+        return unless quantity && unit && dispatch_plan_item
+
+        authorizations = HubAuthorization.where(
           dispatch_plan_item: dispatch_plan_item,
           authorization_type: authorization_type
-        ).sum(:quantity)
-        used -= quantity_was if quantity_was
-
-        remaining = total - used
-        errors.add(:quantity, "exceeds allocated quantity. Maximum allowed is #{remaining}") if quantity > remaining
+        )
+        ValidationUtil.validate_quantity(self, 'dispatch_plan_item', authorizations, 'allocated')
       end
     end
   end

data/app/models/cats/core/lost_commodity.rb

@@ -1,9 +1,38 @@
 module Cats
   module Core
     class LostCommodity < ApplicationRecord
+      before_validation :set_unit
+
       belongs_to :receipt_authorization
+      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
 
       validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validate :validate_quantity
+
+      delegate(:abbreviation, to: :unit, prefix: true)
+
+      def set_unit
+        return if unit
+
+        return unless receipt_authorization
+
+        self.unit = receipt_authorization.unit
+      end
+
+      def validate_quantity
+        return unless quantity && unit && receipt_authorization
+
+        total = UnitConversion.convert(receipt_authorization.unit, unit, receipt_authorization.quantity)
+        receipts = Receipt.where(receipt_authorization: receipt_authorization)
+        losses = LostCommodity.where(receipt_authorization: receipt_authorization)
+        used = UnitConversion.harmonized_total(receipts, unit) + UnitConversion.harmonized_total(losses, unit)
+        used -= quantity_was if quantity_was
+
+        remaining = total - used
+        return unless quantity > remaining
+
+        errors.add(:quantity, "exceeds authorized quantity. Maximum allowed is #{remaining} #{unit.abbreviation}")
+      end
     end
   end
 end

data/app/models/cats/core/receipt.rb

@@ -1,11 +1,33 @@
 module Cats
   module Core
     class Receipt < ApplicationRecord
+      before_validation :set_unit
+
       belongs_to :receipt_authorization
+      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
 
       validates :commodity_status, presence: true, inclusion: { in: Commodity::COMMODITY_STATUSES }
       validates :commodity_grade, inclusion: { in: Commodity::COMMODITY_GRADES }, allow_nil: true
       validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validate :validate_quantity
+
+      delegate(:abbreviation, to: :unit, prefix: true)
+
+      def set_unit
+        return if unit
+
+        return unless receipt_authorization
+
+        self.unit = receipt_authorization.unit
+      end
+
+      def validate_quantity
+        return unless quantity && unit && receipt_authorization
+
+        receipts = Receipt.where(receipt_authorization: receipt_authorization)
+        losses = LostCommodity.where(receipt_authorization: receipt_authorization)
+        ValidationUtil.validate_quantity(self, 'receipt_authorization', receipts + losses, 'authorized')
+      end
     end
   end
 end

data/app/models/cats/core/receipt_authorization.rb

@@ -6,16 +6,13 @@ module Cats
       has_many :receipt_transactions
 
       validates :received_quantity, presence: true, numericality: { greater_than_or_equal_to: 0 }
-      validate :validate_total_quantity
+      validate :validate_quantity
 
-      def validate_total_quantity
-        return unless dispatch && quantity
+      def validate_quantity
+        return unless dispatch && quantity && unit
 
-        received = dispatch.receipt_authorizations.sum(:quantity)
-        diff = dispatch.quantity - received
-        diff += quantity_was if quantity_was
-
-        errors.add(:quantity, "authorized is higher than dispatch quantity (Max = #{diff}).") if quantity > diff
+        authorizations = ReceiptAuthorization.where(dispatch: dispatch)
+        ValidationUtil.validate_quantity(self, 'dispatch', authorizations, 'dispatch')
       end
     end
   end

data/app/models/cats/core/receipt_transaction.rb

@@ -1,6 +1,8 @@
 module Cats
   module Core
     class ReceiptTransaction < Transaction
+      before_validation :set_unit
+
       belongs_to :receipt_authorization
       belongs_to :destination, class_name: 'Cats::Core::Stack'
 
@@ -11,6 +13,14 @@ module Cats
       delegate(:code, to: :destination, prefix: true)
       delegate(:dispatch_reference_no, to: :receipt_authorization)
 
+      def set_unit
+        return if unit
+
+        return unless receipt_authorization
+
+        self.unit = receipt_authorization.unit
+      end
+
       def validate_receipt
         return unless receipt_authorization
 
@@ -21,15 +31,13 @@ module Cats
       def validate_quantity
         return unless quantity && destination && receipt_authorization
 
-        total = ReceiptTransaction.where(receipt_authorization: receipt_authorization).sum(:quantity)
-        diff = receipt_authorization.quantity - total
-        diff += quantity_was if quantity_was
-        errors.add(:quantity, "exceeds authorized quantity (Max. = #{diff}).") if quantity > diff
+        transactions = ReceiptTransaction.where(receipt_authorization: receipt_authorization)
+        ValidationUtil.validate_quantity(self, 'receipt_authorization', transactions, 'authorized')
       end
 
       def commit
         ReceiptTransaction.transaction do
-          destination.quantity += quantity
+          destination.quantity += UnitConversion.convert(unit, destination.unit, quantity)
           destination.stack_status = Cats::Core::Stack::ALLOCATED
           destination.save!
           self.status = COMMITTED