cats_core 1.5.16 → 1.5.18

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

@@ -1,12 +1,12 @@
 module Cats
   module Core
     class Location < ApplicationRecord
-      REGION = 'Region'.freeze
-      ZONE = 'Zone'.freeze
-      WOREDA = 'Woreda'.freeze
-      FDP = 'Fdp'.freeze
-      HUB = 'Hub'.freeze
-      WAREHOUSE = 'Warehouse'.freeze
+      REGION = "Region".freeze
+      ZONE = "Zone".freeze
+      WOREDA = "Woreda".freeze
+      FDP = "Fdp".freeze
+      HUB = "Hub".freeze
+      WAREHOUSE = "Warehouse".freeze
 
       LOCATION_TYPES = [REGION, ZONE, WOREDA, FDP, HUB, WAREHOUSE].freeze
 
@@ -14,7 +14,7 @@ module Cats
 
       validates :code, :name, :location_type, presence: true
       validates :code, uniqueness: true
-      validates :location_type, inclusion: { in: LOCATION_TYPES }
+      validates :location_type, inclusion: {in: LOCATION_TYPES}
       validate :validate_location_parent
 
       delegate(:code, to: :parent, prefix: true, allow_nil: true)
@@ -35,7 +35,7 @@ module Cats
         return if location_type == REGION && parent.nil?
 
         # Check that parent is not nil for locations other than region
-        errors.add(:location, 'parent cannot be empty') if location_type != REGION && parent.nil?
+        errors.add(:location, "parent cannot be empty") if location_type != REGION && parent.nil?
 
         # At this point, we may return if parent.nil? is true
         # because the above statement already took care of that.
@@ -53,6 +53,10 @@ module Cats
 
         Store.find_by(code: "FDP-ST-#{code}")
       end
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["code", "location_type", "name"]
+      end
     end
   end
 end

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

@@ -4,9 +4,9 @@ module Cats
       before_validation :set_unit
 
       belongs_to :receipt_authorization
-      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}
       validate :validate_quantity
 
       delegate(:abbreviation, to: :unit, prefix: true)

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

@@ -6,11 +6,11 @@ module Cats
       belongs_to :recipient, polymorphic: true
 
       def message
-        { id: id, read: !read_at.nil?, created_at: created_at }.merge(to_notification.message)
+        {id: id, read: !read_at.nil?, created_at: created_at}.merge(to_notification.message)
       end
 
       def self.messages(notifications)
-        notifications.includes(:recipient).map(&:message)
+        notifications.map(&:message)
       end
     end
   end

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

@@ -4,14 +4,14 @@ module Cats
       belongs_to :transport_offer
       belongs_to :transport_bid_item
 
-      validates :price, presence: true, numericality: { greater_than_or_equal_to: 0 }
-      validates :rank, numericality: { greater_than: 0 }, allow_nil: true
+      validates :price, presence: true, numericality: {greater_than_or_equal_to: 0}
+      validates :rank, numericality: {greater_than: 0}, allow_nil: true
       validate :validate_rank_is_set_for_winner
 
       delegate(:route, to: :transport_bid_item)
 
       def mark_as_winner(rank)
-        raise(StandardError, 'Offer item already marked as winner.') if winner
+        raise(StandardError, "Offer item already marked as winner.") if winner
 
         self.rank = rank
         self.winner = true
@@ -21,7 +21,7 @@ module Cats
       def validate_rank_is_set_for_winner
         return if rank
 
-        errors.add(:winner, 'cannot be set for a non-ranked offer item.') if winner
+        errors.add(:winner, "cannot be set for a non-ranked offer item.") if winner
       end
     end
   end

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

@@ -1,15 +1,15 @@
 module Cats
   module Core
     class Plan < ApplicationRecord
-      DRAFT = 'Draft'.freeze
-      APPROVED = 'Approved'.freeze
-      NEEDS_APPROVED = 'Needs Approved'.freeze
+      DRAFT = "Draft".freeze
+      APPROVED = "Approved".freeze
+      NEEDS_APPROVED = "Needs Approved".freeze
 
       STATUSES = [DRAFT, APPROVED, NEEDS_APPROVED].freeze
 
-      BELG = 'Belg'.freeze
-      MEHER = 'Meher'.freeze
-      ANNUAL = 'Annual'.freeze
+      BELG = "Belg".freeze
+      MEHER = "Meher".freeze
+      ANNUAL = "Annual".freeze
       SEASONS = [BELG, MEHER, ANNUAL].freeze
 
       belongs_to :program
@@ -23,10 +23,10 @@ module Cats
       delegate(:code, to: :program, prefix: true)
 
       validates :reference_no, :year, :status, presence: true
-      validates :total_days, :rounds, presence: true, numericality: { greater_than: 0 }
-      validates :season, presence: true, inclusion: { in: SEASONS }
+      validates :total_days, :rounds, presence: true, numericality: {greater_than: 0}
+      validates :season, presence: true, inclusion: {in: SEASONS}
       validates :reference_no, uniqueness: true
-      validates :status, inclusion: { in: STATUSES }
+      validates :status, inclusion: {in: STATUSES}
 
       def no_of_round_days
         total_days / rounds

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

@@ -3,16 +3,16 @@ module Cats
     class PlanItem < ApplicationRecord
       belongs_to :plan
 
-      belongs_to :region, -> { where(location_type: Cats::Core::Location::REGION) }, class_name: 'Cats::Core::Location'
-      belongs_to :zone, -> { where(location_type: Cats::Core::Location::ZONE) }, class_name: 'Cats::Core::Location'
-      belongs_to :woreda, -> { where(location_type: Cats::Core::Location::WOREDA) }, class_name: 'Cats::Core::Location'
-      belongs_to :fdp, -> { where(location_type: Cats::Core::Location::FDP) }, class_name: 'Cats::Core::Location'
+      belongs_to :region, -> { where(location_type: Cats::Core::Location::REGION) }, class_name: "Cats::Core::Location"
+      belongs_to :zone, -> { where(location_type: Cats::Core::Location::ZONE) }, class_name: "Cats::Core::Location"
+      belongs_to :woreda, -> { where(location_type: Cats::Core::Location::WOREDA) }, class_name: "Cats::Core::Location"
+      belongs_to :fdp, -> { where(location_type: Cats::Core::Location::FDP) }, class_name: "Cats::Core::Location"
       belongs_to :operator
 
       has_many :beneficiary_plan_items
       has_many :plan_item_details, through: :beneficiary_plan_items
 
-      validates :plan_id, uniqueness: { scope: :fdp_id }
+      validates :plan_id, uniqueness: {scope: :fdp_id}
 
       delegate(:name, to: :region, prefix: true)
       delegate(:name, to: :zone, prefix: true)

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

@@ -4,8 +4,8 @@ module Cats
       belongs_to :beneficiary_plan_item
       belongs_to :ration
 
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
-      validates :beneficiary_plan_item_id, uniqueness: { scope: :ration_id }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
+      validates :beneficiary_plan_item_id, uniqueness: {scope: :ration_id}
     end
   end
 end

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

@@ -6,7 +6,7 @@ module Cats
 
       validates :code, presence: true, uniqueness: true
       validates :year, :implementing_agency, presence: true
-      validates :year, numericality: { greater_than: 2000 }
+      validates :year, numericality: {greater_than: 2000}
 
       delegate(:code, to: :program, prefix: true)
       delegate(:reference_no, to: :source, prefix: true)

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

@@ -1,19 +1,19 @@
 module Cats
   module Core
     class PurchaseOrder < ApplicationRecord
-      LOCAL = 'Local'.freeze
-      FOREIGN = 'Foreign'.freeze
+      LOCAL = "Local".freeze
+      FOREIGN = "Foreign".freeze
       PURCHASE_TYPES = [LOCAL, FOREIGN].freeze
 
       belongs_to :cash_donation
       belongs_to :commodity_category
       belongs_to :currency
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       validates :reference_no, :order_date, :supplier, :purchase_type, presence: true
       validates :reference_no, uniqueness: true
-      validates :purchase_type, inclusion: { in: PURCHASE_TYPES }
-      validates :quantity, :price, presence: true, numericality: { greater_than: 0 }
+      validates :purchase_type, inclusion: {in: PURCHASE_TYPES}
+      validates :quantity, :price, presence: true, numericality: {greater_than: 0}
 
       delegate(:name, to: :commodity_category, prefix: true)
       delegate(:name, to: :unit, prefix: true)

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

@@ -6,7 +6,7 @@ module Cats
       belongs_to :unit_of_measure
 
       validates :reference_no, presence: true, uniqueness: true
-      validates :quantity, :no_of_days, presence: true, numericality: { greater_than: 0 }
+      validates :quantity, :no_of_days, presence: true, numericality: {greater_than: 0}
 
       delegate(:name, to: :commodity_category, prefix: true)
       delegate(:name, to: :beneficiary_category, prefix: true)

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

@@ -4,11 +4,11 @@ module Cats
       before_validation :set_unit
 
       belongs_to :receipt_authorization
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      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 }
+      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}
       # validates :reference_no, presence: true
       validate :validate_quantity
 
@@ -27,7 +27,7 @@ module Cats
 
         receipts = Receipt.where(receipt_authorization: receipt_authorization)
         losses = LostCommodity.where(receipt_authorization: receipt_authorization)
-        ValidationUtil.validate_quantity(self, 'receipt_authorization', receipts + losses, 'authorized')
+        ValidationUtil.validate_quantity(self, "receipt_authorization", receipts + losses, "authorized")
       end
     end
   end

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

@@ -5,14 +5,18 @@ module Cats
       has_many :lost_commodities
       has_many :receipt_transactions
 
-      validates :received_quantity, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :received_quantity, presence: true, numericality: {greater_than_or_equal_to: 0}
       validate :validate_quantity
 
       def validate_quantity
         return unless dispatch && quantity && unit
 
         authorizations = ReceiptAuthorization.where(dispatch: dispatch)
-        ValidationUtil.validate_quantity(self, 'dispatch', authorizations, 'dispatch')
+        ValidationUtil.validate_quantity(self, "dispatch", authorizations, "dispatch")
+      end
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["authorized_by_id", "dispatch_id", "received_quantity", "quantity", "status", "store_id", "unit_id"]
       end
     end
   end

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

@@ -4,10 +4,10 @@ module Cats
       before_validation :set_unit
 
       belongs_to :receipt_authorization
-      belongs_to :destination, class_name: 'Cats::Core::Stack'
+      belongs_to :destination, class_name: "Cats::Core::Stack"
 
       validates :transaction_date, presence: true
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
       validates :receipt_number, presence: true
       validate :validate_receipt, :validate_quantity
 
@@ -26,14 +26,14 @@ module Cats
         return unless receipt_authorization
 
         status = receipt_authorization.status
-        errors.add(:receipt_authorization, 'must be confirmed.') if status == ReceiptAuthorization::AUTHORIZED
+        errors.add(:receipt_authorization, "must be confirmed.") if status == ReceiptAuthorization::AUTHORIZED
       end
 
       def validate_quantity
         return unless quantity && destination && receipt_authorization
 
         transactions = ReceiptTransaction.where(receipt_authorization: receipt_authorization)
-        ValidationUtil.validate_quantity(self, 'receipt_authorization', transactions, 'authorized')
+        ValidationUtil.validate_quantity(self, "receipt_authorization", transactions, "authorized")
       end
 
       def commit
@@ -45,6 +45,10 @@ module Cats
           save!
         end
       end
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["destination_id", "quantity", "receipt_authorization_id", "receipt_number", "status", "transaction_date", "unit_id"]
+      end
     end
   end
 end

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

@@ -5,16 +5,16 @@ module Cats
 
       before_validation :set_unit
 
-      ALLOCATED = 'Allocated'.freeze
+      ALLOCATED = "Allocated".freeze
       STATUSES << ALLOCATED
 
       belongs_to :commodity
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
 
       validates :reference_no, :request_date, :quantity, presence: true
       validates :reference_no, uniqueness: true
-      validates :quantity, numericality: { greater_than_or_equal_to: 0 }
-      validates :status, presence: true, inclusion: { in: STATUSES }
+      validates :quantity, numericality: {greater_than_or_equal_to: 0}
+      validates :status, presence: true, inclusion: {in: STATUSES}
       validate :validate_commodity_status, :validate_quantity
 
       delegate(:batch_no, to: :commodity, prefix: true)
@@ -39,7 +39,7 @@ module Cats
       def validate_commodity_status
         return unless commodity
 
-        errors.add(:commodity, 'should be approved first.') unless commodity.status == Commodity::APPROVED
+        errors.add(:commodity, "should be approved first.") unless commodity.status == Commodity::APPROVED
       end
 
       def validate_quantity
@@ -61,21 +61,21 @@ module Cats
       end
 
       def approve
-        raise(StandardError, 'Request is not in draft state.') unless status == DRAFT
+        raise(StandardError, "Request is not in draft state.") unless status == DRAFT
 
         self.status = APPROVED
         save!
       end
 
       def complete
-        raise(StandardError, 'Request is not approved.') unless status == APPROVED
+        raise(StandardError, "Request is not approved.") unless status == APPROVED
 
         self.status = COMPLETED
         save!
       end
 
       def allocate
-        raise(StandardError, 'Request is not completed.') unless status == COMPLETED
+        raise(StandardError, "Request is not completed.") unless status == COMPLETED
 
         self.status = ALLOCATED
         save!

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

@@ -12,7 +12,7 @@ module Cats
 
         return if role.application_module_id == menu.application_module.id
 
-        errors.add(:base, 'Application module does not match for role and menu')
+        errors.add(:base, "Application module does not match for role and menu")
       end
 
       delegate(:label, to: :menu, prefix: false)

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

@@ -4,13 +4,21 @@ module Cats
       belongs_to :beneficiary
       belongs_to :round_plan_item
       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(:full_name, to: :beneficiary, prefix: true)
       delegate(:name, to: :commodity_category, prefix: true)
       delegate(:abbreviation, to: :unit, prefix: true)
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["beneficiary_id", "commodity_category_id", "quantity", "received", "round_plan_item_id", "unit_id"]
+      end
+
+      def self.ransackable_associations(auth_object = nil)
+        ["beneficiary", "commodity_category", "round_plan_item", "unit"]
+      end
     end
   end
 end

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

@@ -3,14 +3,14 @@ module Cats
     class RoundPlan < ApplicationRecord
       include Dispatchable
 
-      NEEDS_APPROVED = 'Needs Approved'.freeze
-      IN_PROGRESS = 'In Progress'.freeze
+      NEEDS_APPROVED = "Needs Approved".freeze
+      IN_PROGRESS = "In Progress".freeze
 
       STATUSES << NEEDS_APPROVED
       STATUSES << IN_PROGRESS
 
       belongs_to :plan
-      belongs_to :region, class_name: 'Cats::Core::Location'
+      belongs_to :region, class_name: "Cats::Core::Location"
 
       has_many :round_plan_items
       has_many :round_rations
@@ -20,7 +20,7 @@ module Cats
 
       validates :rounds, presence: true
       validates :reference_no, presence: true, uniqueness: true
-      validates :status, presence: true, inclusion: { in: RoundPlan::STATUSES }
+      validates :status, presence: true, inclusion: {in: RoundPlan::STATUSES}
       validate :validate_region
       validate :validate_rounds, on: :create
 
@@ -37,15 +37,15 @@ module Cats
       end
 
       def approve
-        raise(StandardError, 'Plan is not in draft state.') unless status == DRAFT
+        raise(StandardError, "Plan is not in draft state.") unless status == DRAFT
 
-        raise(StandardError, 'Empty plan cannot be approved.') if round_plan_items.count.zero?
+        raise(StandardError, "Empty plan cannot be approved.") if round_plan_items.count.zero?
 
         update!(status: APPROVED)
       end
 
       def in_progress
-        raise(StandardError, 'Plan is not approved.') unless status == APPROVED
+        raise(StandardError, "Plan is not approved.") unless status == APPROVED || status == IN_PROGRESS
 
         self.status = IN_PROGRESS
         save!
@@ -54,22 +54,26 @@ module Cats
       def validate_rounds
         return unless rounds && plan
 
-        errors.add(:rounds, 'cannot be an empty list') if rounds.empty?
+        errors.add(:rounds, "cannot be an empty list") if rounds.empty?
 
         existing_rounds = plan.round_plans.where(region: region).map(&:rounds).sum([])
         rounds.each do |round|
           if round > plan.rounds
-            errors.add(:rounds, 'cannot exceed the total number of rounds specified in the plan.')
+            errors.add(:rounds, "cannot exceed the total number of rounds specified in the plan.")
             break
           end
         end
-        errors.add(:rounds, 'cannot be repeated.') unless existing_rounds - rounds == existing_rounds
+        errors.add(:rounds, "cannot be repeated.") unless existing_rounds - rounds == existing_rounds
       end
 
       def validate_region
         return unless region
 
-        errors.add(:region, 'is not valid.') unless region.location_type == Location::REGION
+        errors.add(:region, "is not valid.") unless region.location_type == Location::REGION
+      end
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["plan_id", "reference_no", "region_id", "rounds", "status"]
       end
     end
   end

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

@@ -2,10 +2,10 @@ module Cats
   module Core
     class RoundPlanItem < ApplicationRecord
       belongs_to :round_plan
-      belongs_to :region, -> { where(location_type: Cats::Core::Location::REGION) }, class_name: 'Cats::Core::Location'
-      belongs_to :zone, -> { where(location_type: Cats::Core::Location::ZONE) }, class_name: 'Cats::Core::Location'
-      belongs_to :woreda, -> { where(location_type: Cats::Core::Location::WOREDA) }, class_name: 'Cats::Core::Location'
-      belongs_to :fdp, -> { where(location_type: Cats::Core::Location::FDP) }, class_name: 'Cats::Core::Location'
+      belongs_to :region, -> { where(location_type: Cats::Core::Location::REGION) }, class_name: "Cats::Core::Location"
+      belongs_to :zone, -> { where(location_type: Cats::Core::Location::ZONE) }, class_name: "Cats::Core::Location"
+      belongs_to :woreda, -> { where(location_type: Cats::Core::Location::WOREDA) }, class_name: "Cats::Core::Location"
+      belongs_to :fdp, -> { where(location_type: Cats::Core::Location::FDP) }, class_name: "Cats::Core::Location"
       belongs_to :operator
 
       has_many :beneficiary_round_plan_items
@@ -13,7 +13,7 @@ module Cats
       has_many :round_beneficiaries
 
       validates :plan_item_id, presence: true
-      validates :round_plan_id, uniqueness: { scope: :fdp_id }
+      validates :round_plan_id, uniqueness: {scope: :fdp_id}
 
       delegate(:reference_no, to: :round_plan, prefix: true)
       delegate(:name, to: :region, prefix: true)
@@ -21,6 +21,10 @@ module Cats
       delegate(:name, to: :woreda, prefix: true)
       delegate(:name, to: :fdp, prefix: true)
       delegate(:name, to: :operator, prefix: true)
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["fdp_id", "operator_id", "plan_item_id", "region_id", "round_plan_id", "woreda_id", "zone_id"]
+      end
     end
   end
 end

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

@@ -3,10 +3,10 @@ module Cats
     class RoundPlanItemDetail < ApplicationRecord
       belongs_to :beneficiary_round_plan_item
       belongs_to :round_ration
-      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 :beneficiary_round_plan_item_id, uniqueness: { scope: :round_ration_id }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
+      validates :beneficiary_round_plan_item_id, uniqueness: {scope: :round_ration_id}
 
       delegate(:abbreviation, to: :unit, prefix: true)
       delegate(:commodity_category_name, to: :round_ration, prefix: false)

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

@@ -6,8 +6,8 @@ module Cats
       belongs_to :unit_of_measure
       belongs_to :round_plan
 
-      validates :quantity, presence: true, numericality: { greater_than_or_equal_to: 0 }
-      validates :no_of_days, presence: true, numericality: { greater_than: 0 }
+      validates :quantity, presence: true, numericality: {greater_than_or_equal_to: 0}
+      validates :no_of_days, presence: true, numericality: {greater_than: 0}
 
       delegate(:name, to: :commodity_category, prefix: true)
       delegate(:name, to: :beneficiary_category, prefix: true)

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

@@ -3,11 +3,11 @@ module Cats
     class Route < ApplicationRecord
       before_validation :set_name, on: %i[create update]
 
-      belongs_to :region, class_name: 'Cats::Core::Location'
-      belongs_to :source, class_name: 'Cats::Core::Location'
-      belongs_to :destination, class_name: 'Cats::Core::Location'
+      belongs_to :region, class_name: "Cats::Core::Location"
+      belongs_to :source, class_name: "Cats::Core::Location"
+      belongs_to :destination, class_name: "Cats::Core::Location"
 
-      validates :source_id, uniqueness: { scope: :destination_id }
+      validates :source_id, uniqueness: {scope: :destination_id}
       validate :validate_region, :validate_source, :validate_destination, :validate_route
 
       delegate(:name, to: :region, prefix: true)
@@ -21,19 +21,19 @@ module Cats
       def validate_region
         return unless region
 
-        errors.add(:region, 'should be a valid region.') unless region.location_type == Location::REGION
+        errors.add(:region, "should be a valid region.") unless region.location_type == Location::REGION
       end
 
       def validate_source
         return unless source
 
-        errors.add(:source, 'cannot be a region.') if source.location_type == Location::REGION
+        errors.add(:source, "cannot be a region.") if source.location_type == Location::REGION
       end
 
       def validate_destination
         return unless destination
 
-        errors.add(:destination, 'cannot be a region.') if destination.location_type == Location::REGION
+        errors.add(:destination, "cannot be a region.") if destination.location_type == Location::REGION
       end
 
       def validate_route
@@ -41,7 +41,11 @@ module Cats
 
         return unless destination
 
-        errors.add(:base, 'Source and destination cannot be the same') if source == destination
+        errors.add(:base, "Source and destination cannot be the same") if source == destination
+      end
+
+      def self.ransackable_attributes(auth_object = nil)
+        ["destination_id", "name", "region_id", "source_id"]
       end
     end
   end