cats_core 1.5.16 → 1.5.18

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

@@ -2,47 +2,47 @@ module Cats
   module Core
     class Stack < ApplicationRecord
       # Stack statuses
-      RESERVED = 'Reserved'.freeze
-      ALLOCATED = 'Allocated'.freeze
-      DESTROYED = 'Destroyed'.freeze
+      RESERVED = "Reserved".freeze
+      ALLOCATED = "Allocated".freeze
+      DESTROYED = "Destroyed".freeze
       STACK_STATUSES = [RESERVED, ALLOCATED, DESTROYED].freeze
 
       belongs_to :commodity
       belongs_to :store
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       has_many :dispatch_transactions, foreign_key: :source_id
       has_many :receipt_transactions, foreign_key: :destination_id
 
       validates :code, :length, :width, :height, :start_x, :start_y, :commodity_status, :stack_status,
-                :quantity, presence: true
+        :quantity, presence: true
       validates :code, uniqueness: true
-      validates :length, :width, :height, :start_x, :start_y, numericality: { greater_than: 0 }
-      validates :quantity, numericality: { greater_than_or_equal_to: 0 }
-      validates :commodity_status, inclusion: { in: Cats::Core::Commodity::COMMODITY_STATUSES }
-      validates :stack_status, inclusion: { in: STACK_STATUSES }
+      validates :length, :width, :height, :start_x, :start_y, numericality: {greater_than: 0}
+      validates :quantity, numericality: {greater_than_or_equal_to: 0}
+      validates :commodity_status, inclusion: {in: Cats::Core::Commodity::COMMODITY_STATUSES}
+      validates :stack_status, inclusion: {in: STACK_STATUSES}
       validate :validate_coordinates, :validate_dimensions, :validate_distance_from_wall, :validate_overlap,
-               :validate_space_between_stack, :validate_max_height, :validate_max_length, :validate_max_width,
-               :validate_distance_from_ceiling,
-               unless: -> { store && (store.code == 'SUP-STORE' || store.code.start_with?('FDP-ST')) }
+        :validate_space_between_stack, :validate_max_height, :validate_max_length, :validate_max_width,
+        :validate_distance_from_ceiling,
+        unless: -> { store && (store.code == "SUP-STORE" || store.code.start_with?("FDP-ST")) }
 
       delegate :batch_no, to: :commodity, prefix: true
       delegate :abbreviation, to: :unit, prefix: true
 
-      after_save :update_store_space, :destroy_stack
+      after_save :update_store_space
 
       def validate_coordinates
         return unless store.present? && length.present? && width.present? && start_x.present? && start_y.present?
 
-        errors.add(:start_x, 'cannot exceed length') if start_x.present? && start_x > store.length
-        errors.add(:start_y, 'cannot exceed width') if start_y.present? && start_y > store.width
+        errors.add(:start_x, "cannot exceed length") if start_x.present? && start_x > store.length
+        errors.add(:start_y, "cannot exceed width") if start_y.present? && start_y > store.width
       end
 
       def validate_dimensions
         return unless store.present? && length.present? && width.present? && start_x.present? && start_y.present?
 
-        errors.add(:length, 'cannot exceed store length') if start_x + length > store.length
-        errors.add(:width, 'cannot exceed store width') if start_y + width > store.width
+        errors.add(:length, "cannot exceed store length") if start_x + length > store.length
+        errors.add(:width, "cannot exceed store width") if start_y + width > store.width
       end
 
       def stacking_rules
@@ -66,9 +66,9 @@ module Cats
 
         rule = stacking_rules
         if start_x < rule.distance_from_wall || store.length - (start_x + length) < rule.distance_from_wall ||
-           store.width - (start_y + width) < rule.distance_from_wall || start_y < rule.distance_from_wall
+            store.width - (start_y + width) < rule.distance_from_wall || start_y < rule.distance_from_wall
           errors.add(:base,
-                     message: "The stack must be placed #{rule.distance_from_wall} meter away from a store wall")
+            message: "The stack must be placed #{rule.distance_from_wall} meter away from a store wall")
         end
       end
 
@@ -89,9 +89,9 @@ module Cats
         rule = stacking_rules
         new_stack = dup
         new_stack.assign_attributes(start_x: start_x - rule.space_between_stack,
-                                    start_y: start_y - rule.space_between_stack,
-                                    length: length + (2 * rule.space_between_stack),
-                                    width: width + (2 * rule.space_between_stack))
+          start_y: start_y - rule.space_between_stack,
+          length: length + (2 * rule.space_between_stack),
+          width: width + (2 * rule.space_between_stack))
         stacks.each do |s|
           errors.add(:base, message: "#{code} overlaps with #{s.code}") if overlaps?(new_stack, s)
         end
@@ -100,19 +100,19 @@ module Cats
       def validate_max_height
         return unless height
 
-        errors.add(:height, 'exceeds stacking rule height.') if height > stacking_rules.maximum_height
+        errors.add(:height, "exceeds stacking rule height.") if height > stacking_rules.maximum_height
       end
 
       def validate_max_length
         return unless length
 
-        errors.add(:length, 'exceeds stacking rule length.') if length > stacking_rules.maximum_length
+        errors.add(:length, "exceeds stacking rule length.") if length > stacking_rules.maximum_length
       end
 
       def validate_max_width
         return unless width
 
-        errors.add(:width, 'exceeds stacking rule width.') if width > stacking_rules.maximum_width
+        errors.add(:width, "exceeds stacking rule width.") if width > stacking_rules.maximum_width
       end
 
       def validate_distance_from_ceiling
@@ -120,7 +120,7 @@ module Cats
 
         return unless store.height - height < stacking_rules.distance_from_ceiling
 
-        errors.add(:height, 'of stack is close to the ceiling.')
+        errors.add(:height, "of stack is close to the ceiling.")
       end
 
       # A method that checks if an overlap exists b/n two stacks.
@@ -140,10 +140,10 @@ module Cats
         return unless length_previously_changed? || width_previously_changed? || stack_status_previously_changed?
 
         old_area = if length_previously_was.nil? && width_previously_was.nil?
-                     0
-                   else
-                     length_previously_was * width_previously_was
-                   end
+          0
+        else
+          length_previously_was * width_previously_was
+        end
 
         store.available_space += old_area
         store.available_space -= length * width unless stack_status == DESTROYED
@@ -154,7 +154,7 @@ module Cats
       def self.search_commodity(batch_no)
         commodity = Commodity.find_by(batch_no: batch_no)
         stacks = Stack.joins(:commodity, store: :warehouse).where(
-          commodity: { batch_no: batch_no },
+          commodity: {batch_no: batch_no},
           stack_status: Stack::ALLOCATED
         )
         stacks.map do |stack|
@@ -171,10 +171,28 @@ module Cats
       end
 
       def destroy_stack
-        return unless stack_status == Cats::Core::Stack::ALLOCATED && quantity.zero?
+        if stack_status == Cats::Core::Stack::RESERVED || quantity.zero?
+          self.stack_status = Cats::Core::Stack::DESTROYED
+          save!
+        else
+          raise(StandardError, "Stack has to be either RESERVED or with zero quantity to be destroyed.")
+        end
+      end
 
-        self.stack_status = Cats::Core::Stack::DESTROYED
-        save!
+      def self.ransackable_attributes(auth_object = nil)
+        [
+          "commodity_id",
+          "commodity_status",
+          "height",
+          "length",
+          "quantity",
+          "stack_status",
+          "start_x",
+          "start_y",
+          "store_id",
+          "unit_id",
+          "width"
+        ]
       end
     end
   end

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

@@ -1,9 +1,9 @@
 module Cats
   module Core
     class StackTransaction < Transaction
-      belongs_to :source, class_name: 'Cats::Core::Stack'
-      belongs_to :destination, class_name: 'Cats::Core::Stack'
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :source, class_name: "Cats::Core::Stack"
+      belongs_to :destination, class_name: "Cats::Core::Stack"
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       def validate_quantity
         return unless quantity.present? && source.present?

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

@@ -2,14 +2,14 @@ module Cats
   module Core
     class StackingRule < ApplicationRecord
       validates :distance_from_wall, :space_between_stack, :distance_from_ceiling, :maximum_height, :maximum_length,
-                :maximum_width, :distance_from_gangway, presence: true, numericality: { greater_than: 0 }
+        :maximum_width, :distance_from_gangway, presence: true, numericality: {greater_than: 0}
       validate :validate_only_a_record_exist
 
       def validate_only_a_record_exist
         return unless StackingRule.count > 1
 
         errors.add(:base,
-                   'There is already a stacking rule entry. A new rule can not be added')
+          "There is already a stacking rule entry. A new rule can not be added")
       end
     end
   end

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

@@ -1,18 +1,18 @@
 module Cats
   module Core
     class Store < ApplicationRecord
-      belongs_to :warehouse, class_name: 'Cats::Core::Location'
+      belongs_to :warehouse, class_name: "Cats::Core::Location"
       has_many :stacks
 
       validates :code, :name, :length, :width, :height, presence: true
       validates :code, uniqueness: true
-      validates :length, :width, :height, numericality: { greater_than: 0 }
+      validates :length, :width, :height, numericality: {greater_than: 0}
       validates :gangway_length, :gangway_width, :gangway_corner_dist, presence: true, if: :has_gangway?
       validates :gangway_length,
-                :gangway_width,
-                :gangway_corner_dist,
-                numericality: { greater_than: 0 },
-                allow_nil: true
+        :gangway_width,
+        :gangway_corner_dist,
+        numericality: {greater_than: 0},
+        allow_nil: true
       validate :validate_location
 
       before_create :update_usable_space
@@ -20,7 +20,7 @@ module Cats
       def validate_location
         return if warehouse.nil?
 
-        errors.add(:warehouse, 'must be a valid warehouse') unless warehouse.location_type == Location::WAREHOUSE
+        errors.add(:warehouse, "must be a valid warehouse") unless warehouse.location_type == Location::WAREHOUSE
       end
 
       def update_usable_space
@@ -28,6 +28,28 @@ module Cats
         self.usable_space -= (gangway_length * gangway_width) if has_gangway
         self.available_space = self.usable_space
       end
+
+      def self.ransackable_attributes(auth_object = nil)
+        [
+          "available_space",
+          "code",
+          "gangway_corner_dist",
+          "gangway_length",
+          "gangway_width",
+          "has_gangway",
+          "height",
+          "length",
+          "name",
+          "temporary",
+          "usable_space",
+          "warehouse_id",
+          "width"
+        ]
+      end
+
+      def self.ransackable_associations(auth_object = nil)
+        ["stacks", "warehouse"]
+      end
     end
   end
 end

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

@@ -1,14 +1,14 @@
 module Cats
   module Core
     class Swap < ApplicationRecord
-      belongs_to :issued_commodity, class_name: 'CommodityCategory'
-      belongs_to :issued_unit, class_name: 'UnitOfMeasure'
-      belongs_to :received_commodity, class_name: 'CommodityCategory'
-      belongs_to :received_unit, class_name: 'UnitOfMeasure'
+      belongs_to :issued_commodity, class_name: "CommodityCategory"
+      belongs_to :issued_unit, class_name: "UnitOfMeasure"
+      belongs_to :received_commodity, class_name: "CommodityCategory"
+      belongs_to :received_unit, class_name: "UnitOfMeasure"
 
       validates :reference_no, presence: true, uniqueness: true
       validates :swapper, :agreement_date, :issued_quantity, :received_quantity, presence: true
-      validates :issued_quantity, :received_quantity, presence: true, numericality: { greater_than: 0 }
+      validates :issued_quantity, :received_quantity, presence: true, numericality: {greater_than: 0}
 
       delegate(:name, to: :issued_commodity, prefix: true)
       delegate(:name, to: :received_commodity, prefix: true)

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

@@ -5,20 +5,20 @@ module Cats
       after_initialize :set_status
 
       # Transaction statuses
-      DRAFT = 'Draft'.freeze
-      COMMITTED = 'Committed'.freeze
+      DRAFT = "Draft".freeze
+      COMMITTED = "Committed".freeze
       STATUSES = [DRAFT, COMMITTED].freeze
 
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       validates :transaction_date, :quantity, :status, presence: true
-      validates :quantity, numericality: { greater_than: 0 }
-      validates :status, inclusion: { in: STATUSES }
+      validates :quantity, numericality: {greater_than: 0}
+      validates :status, inclusion: {in: STATUSES}
 
       delegate(:abbreviation, to: :unit, prefix: true)
 
       def commit
-        raise(NotImplementedError, 'Method should be implemented in child classes.')
+        raise(NotImplementedError, "Method should be implemented in child classes.")
       end
 
       def set_status

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

@@ -1,36 +1,36 @@
 module Cats
   module Core
     class TransportBid < ApplicationRecord
-      NEW = 'New'.freeze
-      OPEN = 'Open'.freeze
-      CLOSED = 'Closed'.freeze
-      RANKED = 'Ranked'.freeze
-      WINNERS_DECLARED = 'Winner Declared'.freeze
+      NEW = "New".freeze
+      OPEN = "Open".freeze
+      CLOSED = "Closed".freeze
+      RANKED = "Ranked".freeze
+      WINNERS_DECLARED = "Winner Declared".freeze
       STATUSES = [NEW, OPEN, CLOSED, RANKED, WINNERS_DECLARED].freeze
 
       has_many :transport_bid_items
       has_many :transport_offers
       has_many :offer_items, through: :transport_offers
       has_many :tenderers
-      belongs_to :region, class_name: 'Cats::Core::Location', optional: true
+      belongs_to :region, class_name: "Cats::Core::Location", optional: true
       belongs_to :transport_plan
 
       validates :reference_no, presence: true, uniqueness: true
       validates :start_date, :end_date, :opening_date, :status, :bid_bond_amount, presence: true
-      validates :bid_bond_amount, numericality: { greater_than_or_equal_to: 0 }
-      validates :status, inclusion: { in: STATUSES }
+      validates :bid_bond_amount, numericality: {greater_than_or_equal_to: 0}
+      validates :status, inclusion: {in: STATUSES}
       validate :validate_start_date_against_end_date
 
       def validate_start_date_against_end_date
         return unless start_date && end_date
 
-        errors.add(:start_date, 'should be before end date.') if start_date >= end_date
+        errors.add(:start_date, "should be before end date.") if start_date >= end_date
       end
 
       def open
-        raise(StandardError, 'Bid is already open.') if status == OPEN
+        raise(StandardError, "Bid is already open.") if status == OPEN
 
-        raise(StandardError, 'Bid is empty.') if transport_bid_items.count.zero?
+        raise(StandardError, "Bid is empty.") if transport_bid_items.count.zero?
 
         self.status = OPEN
         save!
@@ -38,9 +38,9 @@ module Cats
       end
 
       def close
-        raise(StandardError, 'Bid is already closed.') if status == CLOSED
+        raise(StandardError, "Bid is already closed.") if status == CLOSED
 
-        raise(StandardError, 'Bid should first be open.') if status == NEW
+        raise(StandardError, "Bid should first be open.") if status == NEW
 
         self.status = CLOSED
         save!

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

@@ -3,11 +3,11 @@ module Cats
     class TransportBidItem < ApplicationRecord
       belongs_to :transport_bid
       belongs_to :transport_plan_item
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       has_many :offer_items
 
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
       validates :transport_plan_item_id, uniqueness: true
 
       delegate(:reference_no, to: :transport_bid, prefix: true)

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

@@ -6,11 +6,11 @@ module Cats
       has_many :offer_items
 
       validates :offer_date, :bid_bond_amount, presence: true
-      validates :bid_bond_amount, numericality: { greater_than_or_equal_to: 0 }
-      validates :transport_bid_id, uniqueness: { scope: :transporter_id }
+      validates :bid_bond_amount, numericality: {greater_than_or_equal_to: 0}
+      validates :transport_bid_id, uniqueness: {scope: :transporter_id}
 
       delegate(:name, to: :transporter, prefix: true)
-      delegate(:reference_no, to: :transport_bid, prefix: 'bid')
+      delegate(:reference_no, to: :transport_bid, prefix: "bid")
     end
   end
 end

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

@@ -1,30 +1,30 @@
 module Cats
   module Core
     class TransportOrder < ApplicationRecord
-      DRAFT = 'Draft'.freeze
-      APPROVED = 'Approved'.freeze
+      DRAFT = "Draft".freeze
+      APPROVED = "Approved".freeze
       STATUSES = [DRAFT, APPROVED].freeze
 
       belongs_to :transport_requisition
-      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 :transport_order_items
 
-      validates :status, presence: true, inclusion: { in: STATUSES }
+      validates :status, presence: true, inclusion: {in: STATUSES}
       validates :order_date, presence: true
       validate :validate_against_requisition, :validate_status
 
       delegate(:full_name, to: :prepared_by, prefix: true)
       delegate(:full_name, to: :approved_by, prefix: true, allow_nil: true)
-      delegate(:reference_no, to: :transport_requisition, prefix: 'requisition')
+      delegate(:reference_no, to: :transport_requisition, prefix: "requisition")
 
       def validate_against_requisition
         return unless transport_requisition
 
         return if transport_requisition.approved?
 
-        errors.add(:transport_requisition, 'is not approved.')
+        errors.add(:transport_requisition, "is not approved.")
       end
 
       def validate_status
@@ -38,7 +38,7 @@ module Cats
       end
 
       def approve(user)
-        raise(StandardError, 'Transport order is already approved.') if status == APPROVED
+        raise(StandardError, "Transport order is already approved.") if status == APPROVED
 
         begin
           self.status = APPROVED

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

@@ -7,7 +7,7 @@ module Cats
       belongs_to :transport_contract, optional: true
 
       validates :valid_for, presence: true
-      validates :valid_for, numericality: { greater_than: 0 }
+      validates :valid_for, numericality: {greater_than: 0}
       validates :transport_requisition_item_id, uniqueness: true
       validate :validate_requisition
 
@@ -21,7 +21,7 @@ module Cats
 
         return if transport_order.transport_requisition_id == transport_requisition_item.transport_requisition_id
 
-        errors.add(:transport_requisition_item, 'does not belong to the requisition of the order.')
+        errors.add(:transport_requisition_item, "does not belong to the requisition of the order.")
       end
     end
   end

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

@@ -2,15 +2,15 @@ module Cats
   module Core
     class TransportPlan < ApplicationRecord
       # Plan types
-      REGIONAL = 'Regional'.freeze
-      NON_REGIONAL = 'Non Regional'.freeze
+      REGIONAL = "Regional".freeze
+      NON_REGIONAL = "Non Regional".freeze
       PLAN_TYPES = [REGIONAL, NON_REGIONAL].freeze
 
-      belongs_to :region, class_name: 'Cats::Core::Location', optional: true
+      belongs_to :region, class_name: "Cats::Core::Location", optional: true
       has_many :transport_plan_items
 
       validates :reference_no, presence: true, uniqueness: true
-      validates :plan_type, presence: true, inclusion: { in: PLAN_TYPES }
+      validates :plan_type, presence: true, inclusion: {in: PLAN_TYPES}
       validate :validate_region
 
       delegate(:name, to: :region, prefix: true)
@@ -18,11 +18,11 @@ module Cats
       def validate_region
         return unless plan_type
 
-        errors.add(:region, 'should be null.') if plan_type == NON_REGIONAL && region
+        errors.add(:region, "should be null.") if plan_type == NON_REGIONAL && region
 
-        errors.add(:region, 'should not be null.') if plan_type == REGIONAL && !region
+        errors.add(:region, "should not be null.") if plan_type == REGIONAL && !region
 
-        errors.add(:region, 'is not valid.') if region && region.location_type != Location::REGION
+        errors.add(:region, "is not valid.") if region && region.location_type != Location::REGION
       end
     end
   end

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

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

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

@@ -1,23 +1,23 @@
 module Cats
   module Core
     class TransportRequisition < ApplicationRecord
-      DRAFT = 'Draft'.freeze
-      APPROVED = 'Approved'.freeze
+      DRAFT = "Draft".freeze
+      APPROVED = "Approved".freeze
       STATUSES = [DRAFT, APPROVED].freeze
 
       belongs_to :dispatch_plan
-      belongs_to :requested_by, class_name: 'Cats::Core::User'
-      belongs_to :approved_by, class_name: 'Cats::Core::User', optional: true
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :requested_by, class_name: "Cats::Core::User"
+      belongs_to :approved_by, class_name: "Cats::Core::User", optional: true
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       has_many :transport_requisition_items
 
       validates :reference_no, presence: true, uniqueness: true
-      validates :status, presence: true, inclusion: { in: STATUSES }
+      validates :status, presence: true, inclusion: {in: STATUSES}
       validate :validate_status
 
-      delegate(:full_name, to: :requested_by, prefix: 'requestor')
-      delegate(:full_name, to: :approved_by, prefix: 'approver', allow_nil: true)
+      delegate(:full_name, to: :requested_by, prefix: "requestor")
+      delegate(:full_name, to: :approved_by, prefix: "approver", allow_nil: true)
       delegate(:abbreviation, to: :unit, prefix: true)
       delegate(:reference_no, to: :dispatch_plan, prefix: true)
       delegate(:region, to: :dispatch_plan)
@@ -28,7 +28,7 @@ module Cats
       end
 
       def approve(user)
-        raise(StandardError, 'Transport requisition is already approved.') if status == APPROVED
+        raise(StandardError, "Transport requisition is already approved.") if status == APPROVED
 
         begin
           self.status = APPROVED

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

@@ -2,9 +2,9 @@ module Cats
   module Core
     class TransportRequisitionDetail < ApplicationRecord
       belongs_to :transport_requisition_item
-      belongs_to :fdp, class_name: 'Cats::Core::Location'
+      belongs_to :fdp, class_name: "Cats::Core::Location"
 
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
 
       delegate(:name, to: :fdp, prefix: true)
     end

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

@@ -3,11 +3,11 @@ module Cats
     class TransportRequisitionItem < ApplicationRecord
       belongs_to :transport_requisition
       belongs_to :dispatch_plan_item
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
 
-      delegate(:reference_no, to: :transport_requisition, prefix: 'requisition')
+      delegate(:reference_no, to: :transport_requisition, prefix: "requisition")
       delegate(:abbreviation, to: :unit, prefix: true)
       delegate(:source_name, to: :dispatch_plan_item, prefix: false)
 

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

@@ -3,6 +3,10 @@ module Cats
     class Transporter < ApplicationRecord
       validates :code, :name, :address, :contact_phone, presence: true
       validates :code, uniqueness: true
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["address", "code", "contact_phone", "name"]
+      end
     end
   end
 end

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

@@ -1,12 +1,12 @@
 module Cats
   module Core
     class UnitConversion < ApplicationRecord
-      belongs_to :from, class_name: 'Cats::Core::UnitOfMeasure'
-      belongs_to :to, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :from, class_name: "Cats::Core::UnitOfMeasure"
+      belongs_to :to, class_name: "Cats::Core::UnitOfMeasure"
 
       validates :factor, presence: true
-      validates :from_id, uniqueness: { scope: :to_id }
-      validates :factor, numericality: { greater_than: 0 }
+      validates :from_id, uniqueness: {scope: :to_id}
+      validates :factor, numericality: {greater_than: 0}
 
       delegate(:abbreviation, to: :from, prefix: true)
       delegate(:abbreviation, to: :to, prefix: true)

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

@@ -1,13 +1,13 @@
 module Cats
   module Core
     class UnitOfMeasure < ApplicationRecord
-      WEIGHT = 'Weight'.freeze
-      VOLUME = 'Volume'.freeze
-      ITEM = 'Item'.freeze
+      WEIGHT = "Weight".freeze
+      VOLUME = "Volume".freeze
+      ITEM = "Item".freeze
       UNIT_TYPES = [WEIGHT, VOLUME, ITEM].freeze
 
       validates :name, :abbreviation, presence: true, uniqueness: true
-      validates :unit_type, presence: true, inclusion: { in: UNIT_TYPES }
+      validates :unit_type, presence: true, inclusion: {in: UNIT_TYPES}
     end
   end
 end