cats_core 1.5.16 → 1.5.18

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

@@ -2,37 +2,37 @@ module Cats
   module Core
     class Commodity < ApplicationRecord
       # Statuses
-      DRAFT = 'Draft'.freeze
-      APPROVED = 'Approved'.freeze
-      ALLOCATED = 'Allocated'.freeze
+      DRAFT = "Draft".freeze
+      APPROVED = "Approved".freeze
+      ALLOCATED = "Allocated".freeze
       STATUSES = [DRAFT, APPROVED, ALLOCATED].freeze
 
       # Grades
-      GRADE1 = 'Grade1'.freeze
-      GRADE2 = 'Grade2'.freeze
-      GRADE3 = 'Grade3'.freeze
+      GRADE1 = "Grade1".freeze
+      GRADE2 = "Grade2".freeze
+      GRADE3 = "Grade3".freeze
       COMMODITY_GRADES = [GRADE1, GRADE2, GRADE3].freeze
 
       # Commodity statuses
-      GOOD = 'Good'.freeze
-      DAMAGED = 'Damaged'.freeze
-      LEAKAGE = 'Leakage'.freeze
-      WET = 'Wet'.freeze
-      MOLDY = 'Moldy'.freeze
-      INFESTED = 'Infested'.freeze
-      INSECT_INFECTED = 'Insect Infected'.freeze
-      FAECES_FROM_RODENTS = 'Faeces From Rodents'.freeze
-      UNDERWEIGHT_PACKAGE = 'Underweight Package'.freeze
+      GOOD = "Good".freeze
+      DAMAGED = "Damaged".freeze
+      LEAKAGE = "Leakage".freeze
+      WET = "Wet".freeze
+      MOLDY = "Moldy".freeze
+      INFESTED = "Infested".freeze
+      INSECT_INFECTED = "Insect Infected".freeze
+      FAECES_FROM_RODENTS = "Faeces From Rodents".freeze
+      UNDERWEIGHT_PACKAGE = "Underweight Package".freeze
       COMMODITY_STATUSES = [GOOD, DAMAGED, LEAKAGE, WET, MOLDY, INFESTED, INSECT_INFECTED, FAECES_FROM_RODENTS,
-                            UNDERWEIGHT_PACKAGE].freeze
+        UNDERWEIGHT_PACKAGE].freeze
 
       # Arrival Statuses
-      AT_SOURCE = 'At Source'.freeze
-      AT_ORIGIN_PORT = 'At Origin Port'.freeze
-      IN_LOCAL_TRANSIT = 'In Local Transit'.freeze
-      IN_INTERNATIONAL_TRANSIT = 'In International Transit'.freeze
-      AT_DESTINATION_PORT = 'At Destination Port'.freeze
-      ARRIVED = 'Arrived'.freeze
+      AT_SOURCE = "At Source".freeze
+      AT_ORIGIN_PORT = "At Origin Port".freeze
+      IN_LOCAL_TRANSIT = "In Local Transit".freeze
+      IN_INTERNATIONAL_TRANSIT = "In International Transit".freeze
+      AT_DESTINATION_PORT = "At Destination Port".freeze
+      ARRIVED = "Arrived".freeze
       ARRIVAL_STATUSES = [
         AT_SOURCE,
         AT_ORIGIN_PORT,
@@ -44,18 +44,18 @@ module Cats
 
       belongs_to :unit_of_measure
       belongs_to :project
-      belongs_to :package_unit, class_name: 'Cats::Core::UnitOfMeasure', optional: true
+      belongs_to :package_unit, class_name: "Cats::Core::UnitOfMeasure", optional: true
 
       validates :best_use_before, presence: true
       validates :batch_no, presence: true, uniqueness: true
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
-      validates :volume_per_metric_ton, numericality: { greater_than: 0, allow_nil: true }
-      validates :arrival_status, presence: true, inclusion: { in: ARRIVAL_STATUSES }
-      validates :status, presence: true, inclusion: { in: STATUSES }
-      validates :commodity_grade, inclusion: { in: COMMODITY_GRADES }, allow_nil: true
+      validates :quantity, presence: true, numericality: {greater_than: 0}
+      validates :volume_per_metric_ton, numericality: {greater_than: 0, allow_nil: true}
+      validates :arrival_status, presence: true, inclusion: {in: ARRIVAL_STATUSES}
+      validates :status, presence: true, inclusion: {in: STATUSES}
+      validates :commodity_grade, inclusion: {in: COMMODITY_GRADES}, allow_nil: true
       validate :validate_updateability, on: :update
 
-      delegate(:abbreviation, to: :unit_of_measure, prefix: 'unit')
+      delegate(:abbreviation, to: :unit_of_measure, prefix: "unit")
       delegate(:code, to: :project, prefix: true)
       delegate(:abbreviation, to: :package_unit, prefix: true, allow_nil: true)
 
@@ -72,18 +72,18 @@ module Cats
 
         return if status_changed?
 
-        errors.add(:base, 'Commodity cannot be updated because it is in approved state.') if status == APPROVED
+        errors.add(:base, "Commodity cannot be updated because it is in approved state.") if status == APPROVED
       end
 
       def approve
-        raise(StandardError, 'Commodity already approved.') if status == APPROVED
+        raise(StandardError, "Commodity already approved.") if status == APPROVED
 
         result = false
         Cats::Core::Commodity.transaction do
           self.status = APPROVED
           save!
-          store = Cats::Core::Store.find_by(code: 'SUP-STORE')
-          raise(StandardError, 'Supplier store does not exist.') unless store
+          store = Cats::Core::Store.find_by(code: "SUP-STORE")
+          raise(StandardError, "Supplier store does not exist.") unless store
 
           stack = Cats::Core::Stack.create!(
             code: batch_no,
@@ -108,6 +108,20 @@ module Cats
         requests = RhnRequest.where(commodity: self)
         UnitConversion.harmonized_total(requests, unit_of_measure)
       end
+
+      def self.ransackable_attributes(auth_object = nil)
+        [
+          "arrival_status",
+          "batch_no",
+          "best_use_before",
+          "commodity_grade",
+          "package_unit_id",
+          "project_id",
+          "quantity",
+          "shipping_reference",
+          "status"
+        ]
+      end
     end
   end
 end

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

@@ -3,9 +3,9 @@ module Cats
     class CommodityDonation < Donation
       belongs_to :plan, optional: true
       belongs_to :commodity_category
-      belongs_to :unit, class_name: 'UnitOfMeasure'
+      belongs_to :unit, class_name: "UnitOfMeasure"
 
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
 
       delegate(:reference_no, to: :plan, prefix: true, allow_nil: true)
       delegate(:name, to: :commodity_category, prefix: true)

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

@@ -2,21 +2,29 @@ module Cats
   module Core
     class CommoditySubstitution < ApplicationRecord
       belongs_to :program
-      belongs_to :commodity, class_name: 'Cats::Core::CommodityCategory'
-      belongs_to :replaced_by, class_name: 'Cats::Core::CommodityCategory'
+      belongs_to :commodity, class_name: "Cats::Core::CommodityCategory"
+      belongs_to :replaced_by, class_name: "Cats::Core::CommodityCategory"
 
       validates :ratio, presence: true
-      validates :program_id, uniqueness: { scope: %i[commodity_id replaced_by_id] }
+      validates :program_id, uniqueness: {scope: %i[commodity_id replaced_by_id]}
       validate :validate_ratio
 
       def validate_ratio
         return unless ratio
 
-        left, right = ratio.split(':')
-        left_correct = Integer(left).is_a?(Integer) rescue false
-        right_correct = Integer(right).is_a?(Integer) rescue false
+        left, right = ratio.split(":")
+        left_correct = begin
+          Integer(left).is_a?(Integer)
+        rescue
+          false
+        end
+        right_correct = begin
+          Integer(right).is_a?(Integer)
+        rescue
+          false
+        end
 
-        errors.add(:ratio, 'is not in correct format.') unless left_correct && right_correct
+        errors.add(:ratio, "is not in correct format.") unless left_correct && right_correct
       end
     end
   end

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

@@ -3,9 +3,9 @@ module Cats
     class ContractItem < ApplicationRecord
       belongs_to :transport_contract
       belongs_to :route
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
-      validates :price, presence: true, numericality: { greater_than: 0 }
+      validates :price, presence: true, numericality: {greater_than: 0}
 
       delegate(:name, to: :route, prefix: true)
       delegate(:contract_no, to: :transport_contract, prefix: false)

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

@@ -1,19 +1,19 @@
 module Cats
   module Core
     class Dispatch < ApplicationRecord
-      DRAFT = 'Draft'.freeze
-      APPROVED = 'Approved'.freeze
-      READY_TO_START = 'Ready to Start'.freeze
-      STARTED = 'Started'.freeze
-      RECEIVED = 'Received'.freeze
-      STACKED = 'Stacked'.freeze
+      DRAFT = "Draft".freeze
+      APPROVED = "Approved".freeze
+      READY_TO_START = "Ready to Start".freeze
+      STARTED = "Started".freeze
+      RECEIVED = "Received".freeze
+      STACKED = "Stacked".freeze
 
       DISPATCH_STATUSES = [DRAFT, APPROVED, READY_TO_START, STARTED, RECEIVED, STACKED].freeze
 
-      belongs_to :prepared_by, class_name: 'Cats::Core::User'
+      belongs_to :prepared_by, class_name: "Cats::Core::User"
       belongs_to :transporter
       belongs_to :dispatch_plan_item
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       has_many :dispatch_authorizations
       has_many :receipt_authorizations
@@ -21,10 +21,10 @@ module Cats
       has_many :receipt_transactions, through: :receipt_authorizations
 
       validates :reference_no, :plate_no, :driver_name, :driver_phone, :quantity, :commodity_status, presence: true
-      validates :dispatch_status, presence: true, inclusion: { in: DISPATCH_STATUSES }
+      validates :dispatch_status, presence: true, inclusion: {in: DISPATCH_STATUSES}
       validates :reference_no, uniqueness: true
-      validates :quantity, numericality: { greater_than_or_equal_to: 0 }
-      validates :commodity_status, inclusion: { in: Cats::Core::Commodity::COMMODITY_STATUSES }
+      validates :quantity, numericality: {greater_than_or_equal_to: 0}
+      validates :commodity_status, inclusion: {in: Cats::Core::Commodity::COMMODITY_STATUSES}
       validate :validate_dispatch_plan_status
 
       delegate(:name, to: :transporter, prefix: true)
@@ -39,14 +39,14 @@ module Cats
         return unless dispatch_plan_item
 
         status = dispatch_plan_item.dispatch_plan.status
-        errors.add(:dispatch_plan, 'should be approved first.') unless status == DispatchPlan::APPROVED
+        errors.add(:dispatch_plan, "should be approved first.") unless status == DispatchPlan::APPROVED
       end
 
       def approve
-        raise(StandardError, 'Dispatch has to be in draft state.') unless dispatch_status == Dispatch::DRAFT
+        raise(StandardError, "Dispatch has to be in draft state.") unless dispatch_status == Dispatch::DRAFT
 
         # Check if dispatch has authorizations
-        raise(StandardError, 'Dispatch has no authorizations.') unless dispatch_authorizations.count.positive?
+        raise(StandardError, "Dispatch has no authorizations.") unless dispatch_authorizations.count.positive?
 
         dispatch_total = UnitConversion.harmonized_total(dispatch_authorizations, unit)
         self.dispatch_status = APPROVED
@@ -67,7 +67,7 @@ module Cats
 
         # Check if destination is an FDP and create receipt authorization
         location = dispatch_plan_item.destination
-        authorized_by = User.find_by(first_name: 'SYSTEM-USER')
+        authorized_by = User.find_by(first_name: "SYSTEM-USER")
         return unless location.location_type == Location::FDP
 
         store = location.fdp_store
@@ -83,7 +83,7 @@ module Cats
       end
 
       def receive
-        raise(StandardError, 'Dispatch is not started.') unless dispatch_status == Dispatch::STARTED
+        raise(StandardError, "Dispatch is not started.") unless dispatch_status == Dispatch::STARTED
 
         self.dispatch_status = RECEIVED
         save!
@@ -102,10 +102,10 @@ module Cats
       def self.search_commodity(batch_no)
         commodity = Commodity.find_by(batch_no: batch_no)
         dispatches = Dispatch.includes(:dispatch_transactions)
-                             .joins(:transporter)
-                             .where(
-                               dispatch_status: [APPROVED, STARTED]
-                             )
+          .joins(:transporter)
+          .where(
+            dispatch_status: [APPROVED, STARTED]
+          )
         dispatches.map do |dispatch|
           {
             batch_no: batch_no,
@@ -114,10 +114,25 @@ module Cats
             unit: commodity.unit_abbreviation,
             location: dispatch.transporter.name,
             location_detail: "Plate No.: #{dispatch.plate_no}, Driver: #{dispatch.driver_name}",
-            stack: ''
+            stack: ""
           }
         end
       end
+
+      def self.ransackable_attributes(auth_object = nil)
+        [
+          "commodity_status",
+          "dispatch_plan_item_id",
+          "dispatch_status",
+          "driver_name",
+          "driver_phone",
+          "plate_no",
+          "prepared_by_id",
+          "quantity",
+          "transporter_id",
+          "unit_id"
+        ]
+      end
     end
   end
 end

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

@@ -3,23 +3,49 @@ module Cats
     class DispatchAuthorization < Authorization
       has_many :dispatch_transactions
 
-      validate :validate_quantity
+      validate :validate_dispatch_plan_item_quantity, :validate_commodity_availability_in_store
 
       def validate_dispatch_status
         return unless dispatch
 
-        errors.add(:dispatch, 'is not in draft state.') unless dispatch.dispatch_status == Dispatch::DRAFT
+        errors.add(:dispatch, "is not in draft state.") unless dispatch.dispatch_status == Dispatch::DRAFT
       end
 
-      def validate_quantity
+      def validate_dispatch_plan_item_quantity
+        return if status == CONFIRMED
+
         return unless dispatch && quantity && unit
 
         authorizations = DispatchAuthorization.joins(:dispatch).where(
-          dispatch: { dispatch_plan_item_id: dispatch.dispatch_plan_item_id }
+          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)
+        ValidationUtil.validate_quantity(self, "dispatch", authorizations, "allocated", quantity_attribs, unit_attribs)
+      end
+
+      def validate_commodity_availability_in_store
+        return if status == CONFIRMED
+
+        return unless dispatch && store && quantity && unit
+
+        commodity = dispatch.dispatch_plan_item.commodity
+        stacks = Stack.where(store: store, commodity: commodity)
+        if stacks.count == 0
+          errors.add(:store, "does not contain commodity #{commodity.batch_no}.")
+          return
+        end
+        stack_quantity = stacks.map { |s| UnitConversion.convert(s.unit, unit, s.quantity) }.sum
+        authorizations = DispatchAuthorization.where(dispatch: dispatch)
+        authorized = authorizations.map { |a| UnitConversion.convert(a.unit, unit, a.quantity) }.sum
+        authorized -= quantity_was if persisted?
+
+        diff = quantity + authorized - stack_quantity
+        errors.add(:quantity, "exceeds available quantity in store by #{diff} #{unit.abbreviation}.") if diff.positive?
+      end
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["authorized_by_id", "dispatch_id", "quantity", "status", "store_id", "unit_id"]
       end
     end
   end

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

@@ -1,18 +1,18 @@
 module Cats
   module Core
     class DispatchPlan < ApplicationRecord
-      DRAFT = 'Draft'.freeze
-      APPROVED = 'Approved'.freeze
+      DRAFT = "Draft".freeze
+      APPROVED = "Approved".freeze
       STATUSES = [DRAFT, APPROVED].freeze
 
       belongs_to :dispatchable, polymorphic: true, optional: true
-      belongs_to :prepared_by, class_name: 'Cats::Core::User'
-      belongs_to :approved_by, class_name: 'Cats::Core::User', optional: true
+      belongs_to :prepared_by, class_name: "Cats::Core::User"
+      belongs_to :approved_by, class_name: "Cats::Core::User", optional: true
 
       has_many :dispatch_plan_items
 
       validates :reference_no, presence: true, uniqueness: true
-      validates :status, inclusion: { in: STATUSES }
+      validates :status, inclusion: {in: STATUSES}
       validate :validate_dispatchable, on: :create
 
       delegate(:request_reference, to: :dispatchable, allow_nil: true)
@@ -33,18 +33,18 @@ module Cats
 
         return if dispatchable.status == RhnRequest::APPROVED
 
-        errors.add(:dispatchable, 'is already completed.') if id.nil? && dispatchable.status == Dispatchable::COMPLETED
+        errors.add(:dispatchable, "is already completed.") if id.nil? && dispatchable.status == Dispatchable::COMPLETED
       end
 
       def approve
-        raise(StandardError, 'Dispatch plan already approved.') if status == APPROVED
+        raise(StandardError, "Dispatch plan already approved.") if status == APPROVED
 
-        raise(StandardError, 'Dispatch plan is empty.') if dispatch_plan_items.count.zero?
+        raise(StandardError, "Dispatch plan is empty.") if dispatch_plan_items.count.zero?
 
         # Raise error if the total dispatch plan quantity is not equal to the
         # dispatchable quantity
         if dispatchable.instance_of?(RhnRequest) && dispatchable.quantity != quantity
-          raise(StandardError, 'Requested quantity and plan quantity do not match.')
+          raise(StandardError, "Requested quantity and plan quantity do not match.")
         end
 
         self.status = APPROVED
@@ -55,7 +55,7 @@ module Cats
       # A method which returns the total quantity in the dispatch plan
       # based on dispatch plan item quantities.
       def quantity
-        raise(StandardError, 'Dispatchable must be RHN request.') unless dispatchable.instance_of?(RhnRequest)
+        raise(StandardError, "Dispatchable must be RHN request.") unless dispatchable.instance_of?(RhnRequest)
 
         UnitConversion.harmonized_total(dispatch_plan_items, dispatchable.unit)
       end
@@ -66,6 +66,15 @@ module Cats
 
         dispatchable.region.name
       end
+
+      def self.ransackable_attributes(auth_object = nil)
+        [
+          "approved_by_id",
+          "prepared_by_id",
+          "status",
+          "upstream"
+        ]
+      end
     end
   end
 end

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

@@ -1,25 +1,25 @@
 module Cats
   module Core
     class DispatchPlanItem < ApplicationRecord
-      AUTHORIZED = 'Authorized'.freeze
-      SOURCE_AUTHORIZED = 'Source Authorized'.freeze
-      DESTINATION_AUTHORIZED = 'Destination Authorized'.freeze
-      UNAUTHORIZED = 'Unauthorized'.freeze
+      AUTHORIZED = "Authorized".freeze
+      SOURCE_AUTHORIZED = "Source Authorized".freeze
+      DESTINATION_AUTHORIZED = "Destination Authorized".freeze
+      UNAUTHORIZED = "Unauthorized".freeze
       STATUSES = [AUTHORIZED, DESTINATION_AUTHORIZED, SOURCE_AUTHORIZED, UNAUTHORIZED].freeze
 
-      belongs_to :source, class_name: 'Cats::Core::Location'
-      belongs_to :destination, class_name: 'Cats::Core::Location'
+      belongs_to :source, class_name: "Cats::Core::Location"
+      belongs_to :destination, class_name: "Cats::Core::Location"
       belongs_to :dispatch_plan
       belongs_to :commodity
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       has_many :dispatches
       has_many :hub_authorizations
 
       validates :reference_no, presence: true, uniqueness: true
-      validates :commodity_status, presence: true, inclusion: { in: Commodity::COMMODITY_STATUSES }
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
-      validates :status, presence: true, inclusion: { in: STATUSES }
+      validates :commodity_status, presence: true, inclusion: {in: Commodity::COMMODITY_STATUSES}
+      validates :quantity, presence: true, numericality: {greater_than: 0}
+      validates :status, presence: true, inclusion: {in: STATUSES}
 
       delegate(:reference_no, to: :dispatch_plan, prefix: :plan, allow_nil: true)
       delegate(:batch_no, :name, to: :commodity, prefix: true)
@@ -39,7 +39,7 @@ module Cats
       #
       def authorize
         count = hub_authorizations.count
-        raise(StandardError, 'No authorization entries found.') if count.zero?
+        raise(StandardError, "No authorization entries found.") if count.zero?
 
         source_auth = hub_authorizations.where(authorization_type: HubAuthorization::SOURCE)
         dest_auth = hub_authorizations.where(authorization_type: HubAuthorization::DESTINATION)
@@ -47,14 +47,14 @@ module Cats
         if source_auth.count.positive? && dest_auth.count.zero? && status == SOURCE_AUTHORIZED
           raise(
             StandardError,
-            'Plan item already authorized by source. Destination hub authorizations are required.'
+            "Plan item already authorized by source. Destination hub authorizations are required."
           )
         end
 
         if source_auth.count.zero? && dest_auth.count.positive? && status == DESTINATION_AUTHORIZED
           raise(
             StandardError,
-            'Plan item already authorized by destination. Source hub authorizations are required.'
+            "Plan item already authorized by destination. Source hub authorizations are required."
           )
         end
 
@@ -80,13 +80,26 @@ module Cats
         return if quantity == self.quantity
 
         diff = self.quantity - quantity
-        desc = type.split(' ')[0].downcase
+        desc = type.split(" ")[0].downcase
         amount = "#{diff} #{unit.abbreviation}"
         raise(
           StandardError,
           "Authorized #{desc} quantity is not the same as plan item quantity (#{amount} unaccounted for)."
         )
       end
+
+      def self.ransackable_attributes(auth_object = nil)
+        [
+          "commodity_id",
+          "commodity_status",
+          "destination_id",
+          "dispatch_plan_id",
+          "quantity",
+          "source_id",
+          "status",
+          "unit_id"
+        ]
+      end
     end
   end
 end

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

@@ -3,11 +3,10 @@ module Cats
     class DispatchTransaction < Transaction
       before_validation :set_unit
 
-      belongs_to :source, class_name: 'Cats::Core::Stack'
+      belongs_to :source, class_name: "Cats::Core::Stack"
       belongs_to :dispatch_authorization
 
-      validates :source_id, uniqueness: { scope: :dispatch_authorization_id }
-      # validates :reference_no, presence: true
+      validates :source_id, uniqueness: {scope: :dispatch_authorization_id}
       validate :validate_dispatch
       validate :validate_source_quantity, :validate_authorized_quantity, unless: :skip_quantity_validation
 
@@ -35,7 +34,7 @@ module Cats
         return unless dispatch_authorization
 
         status = dispatch_authorization.dispatch.dispatch_status
-        errors.add(:base, 'Dispatch must be approved first.') if status == Dispatch::DRAFT
+        errors.add(:base, "Dispatch must be approved first.") if status == Dispatch::DRAFT
       end
 
       def validate_source_quantity
@@ -56,7 +55,7 @@ module Cats
         return unless quantity && unit && dispatch_authorization
 
         transactions = DispatchTransaction.where(dispatch_authorization: dispatch_authorization)
-        ValidationUtil.validate_quantity(self, 'dispatch_authorization', transactions, 'authorized')
+        ValidationUtil.validate_quantity(self, "dispatch_authorization", transactions, "authorized")
       end
 
       def skip_quantity_validation
@@ -67,6 +66,17 @@ module Cats
 
         ![Dispatch::DRAFT, Dispatch::APPROVED].include?(dispatch_authorization.dispatch.dispatch_status)
       end
+
+      def self.ransackable_attributes(auth_object = nil)
+        [
+          "dispatch_authorization_id",
+          "quantity",
+          "source_id",
+          "status",
+          "transaction_date",
+          "unit_id"
+        ]
+      end
     end
   end
 end

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

@@ -3,13 +3,13 @@ module Cats
     class GiftCertificate < ApplicationRecord
       belongs_to :donation, optional: true
       belongs_to :commodity_category
-      belongs_to :unit, class_name: 'UnitOfMeasure'
+      belongs_to :unit, class_name: "UnitOfMeasure"
       belongs_to :currency
-      belongs_to :destination_warehouse, class_name: 'Location'
+      belongs_to :destination_warehouse, class_name: "Location"
 
       validates :reference_no, presence: true, uniqueness: true
       validates :gift_date, :quantity, :requested_by, :customs_office, presence: true
-      validates :quantity, numericality: { greater_than: 0 }
+      validates :quantity, numericality: {greater_than: 0}
 
       delegate(:name, to: :commodity_category, prefix: true)
       delegate(:name, to: :destination_warehouse, prefix: true)

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

@@ -3,18 +3,18 @@ module Cats
     class HubAuthorization < ApplicationRecord
       before_validation :set_unit
 
-      SOURCE = 'Source'.freeze
-      DESTINATION = 'Destination'.freeze
+      SOURCE = "Source".freeze
+      DESTINATION = "Destination".freeze
       AUTHORIZATION_TYPES = [SOURCE, DESTINATION].freeze
 
       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'
+      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 }
-      validates :authorization_type, inclusion: { in: AUTHORIZATION_TYPES }
+      validates :quantity, numericality: {greater_than: 0}
+      validates :authorization_type, inclusion: {in: AUTHORIZATION_TYPES}
       validate :validate_quantity, on: %i[create update]
 
       delegate(:plan_reference_no, to: :dispatch_plan_item)
@@ -37,7 +37,7 @@ module Cats
           dispatch_plan_item: dispatch_plan_item,
           authorization_type: authorization_type
         )
-        ValidationUtil.validate_quantity(self, 'dispatch_plan_item', authorizations, 'allocated')
+        ValidationUtil.validate_quantity(self, "dispatch_plan_item", authorizations, "allocated")
       end
     end
   end

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

@@ -2,11 +2,11 @@ module Cats
   module Core
     class Loan < ApplicationRecord
       belongs_to :commodity_category
-      belongs_to :unit, class_name: 'UnitOfMeasure'
+      belongs_to :unit, class_name: "UnitOfMeasure"
 
       validates :reference_no, presence: true, uniqueness: true
       validates :lender, :agreement_date, presence: true
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
 
       delegate(:name, to: :commodity_category, prefix: true)
       delegate(:abbreviation, to: :unit, prefix: true)