cats_core 1.4.41 → 1.4.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4084a8e84ceacfb0f4e96ebba6f9c1bfb41cdf64e36341955dfd86131a5de89e
-  data.tar.gz: c091888b5e67a9ecc85e3dce2e5fa33aacab4d617bf31767ded0117329c2f4db
+  metadata.gz: fba88be856ad7a27b81c7eca20c2867775d1bd9963b84d6fa4b48ddaa688008f
+  data.tar.gz: 50ed67dd7ae4dca66b27205764d13c9a72b53d4088158c09b0165c45f4bd12e2
 SHA512:
-  metadata.gz: ca7b27982330acd7df6ebf118e9412fcca962f6436903f7e48c0f1603b5d1bcc1a04b6bb5a508cd7579aa42bedb0e62ed548495759f7a7291b91f3f064ccaaa7
-  data.tar.gz: dac15feb2a1280d856a5ac280498a4b5e7c1585bccdcf74d4a5f78eb41a8e7562c6bdeebf5f53c150586d964cdd2af5663fc5fa588c6765917118526bd7c57c2
+  metadata.gz: 2ed1ee00dbfc76d8bee529ac9e2788b83183159c8f27059b5c14fafab2129ba60b04d83bf503e5efd1e45581391f9a033d18c00ba24bdc6ca15aee3155f5706e
+  data.tar.gz: 2ed989fb152cf0488ce958c373b66b0e1dca324453d82d1ffe3139e4abca362c9926373bc6eb60e85ddb9a7901b466f07711766b682f90de3f020f01df2764df

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

@@ -0,0 +1,19 @@
+module Cats
+  module Core
+    class CashDonationsController < ApplicationController
+      include Common
+
+      def index
+        super do
+          CashDonation.includes(:donor, :currency).all
+        end
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:reference_no, :description, :donated_on, :donor_id, :amount, :currency_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Cats
+  module Core
+    class CommodityDonationsController < ApplicationController
+      include Common
+
+      def index
+        super do
+          CommodityDonation.includes(:donor, :plan, :unit, :commodity_category).all
+        end
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(
+          :reference_no, :description, :shipping_reference, :donated_on, :donor_id, :plan_id, :quantity,
+          :commodity_category_id, :unit_id
+        )
+      end
+    end
+  end
+end

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

@@ -27,6 +27,18 @@ module Cats
         render json: { success: false, error: e.message }, status: :unprocessable_entity
       end
 
+      def generate
+        service = DispatchPlanService.new
+        items = service.generate(params[:id])
+        render json: { success: true, data: serialize(items) }
+      end
+
+      def bulk_create
+        service = DispatchPlanService.new
+        plan = service.bulk_create(bulk_create_params, current_user)
+        render json: { success: true, data: serialize(plan) }
+      end
+
       def approve
         service = DispatchPlanService.new
         plan = DispatchPlan.find(params[:id])
@@ -41,6 +53,18 @@ module Cats
       def model_params
         params.require(:payload).permit(:reference_no, :dispatchable_id, :dispatchable_type)
       end
+
+      def bulk_create_params
+        params.require(:payload).permit(
+          :reference_no,
+          :dispatchable_id,
+          :dispatchable_type,
+          items: %i[
+            reference_no region zone woreda fdp commodity_category unit_id unit quantity source_id destination_id
+            commodity_id
+          ]
+        )
+      end
     end
   end
 end

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

@@ -0,0 +1,20 @@
+module Cats
+  module Core
+    class LoansController < ApplicationController
+      include Common
+
+      def index
+        super do
+          Loan.includes(:commodity_category, :unit).all
+        end
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:reference_no, :lender, :agreement_date, :repayment_date, :quantity, :unit_id,
+                                        :commodity_category_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Cats
+  module Core
+    class PurchaseOrdersController < ApplicationController
+      include Common
+
+      def index
+        purchase_orders = Cats::Core::PurchaseOrder.where(cash_donation_id: params[:id]).includes(
+          :commodity_category,
+          :unit,
+          :currency
+        )
+        render json: { success: true, data: serialize(purchase_orders) }
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:reference_no, :order_date, :requisition_no, :supplier, :cash_donation_id,
+                                        :commodity_category_id, :quantity, :purchase_type, :unit_id, :price,
+                                        :currency_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Cats
+  module Core
+    class RoundBeneficiariesController < ApplicationController
+      include Common
+
+      def index
+        beneficiaries = RoundBeneficiary.joins(:round_plan_item)
+                                        .where(round_plan_item: { round_plan_id: params[:id] })
+                                        .includes(:beneficiary, :commodity_category, :unit)
+        render json: { success: true, data: serialize(beneficiaries) }
+      end
+
+      def generate
+        service = BeneficiaryService.new
+        result = service.generate_distribution_list(params[:id])
+        render json: { success: result }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      def filter
+        query = RoundBeneficiary.includes(:beneficiary, :commodity_category, :unit).ransack(params[:q])
+        render json: { success: true, data: serialize(query.result) }
+      end
+
+      def remove_beneficiaries
+        service = BeneficiaryService.new
+        result = service.remove_items(params[:id], common_params[:ids])
+        render json: { success: result }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      def confirm_receipt
+        service = BeneficiaryService.new
+        result = service.confirm_receipt(params[:id], common_params[:ids])
+        render json: { success: result }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      private
+
+      def common_params
+        params.permit(ids: [])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Cats
+  module Core
+    class SwapsController < ApplicationController
+      include Common
+
+      def index
+        super do
+          Swap.includes(:issued_commodity, :issued_unit, :received_commodity, :received_unit).all
+        end
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:reference_no, :swapper, :agreement_date, :issued_commodity_id,
+                                        :issued_quantity, :received_commodity_id, :received_quantity,
+                                        :issued_unit_id, :received_unit_id)
+      end
+    end
+  end
+end

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

@@ -6,12 +6,21 @@ module Cats
       GENDERS = [MALE, FEMALE].freeze
 
       belongs_to :beneficiary_category
+      belongs_to :fdp, class_name: 'Location'
 
       validates :full_name, :age, :gender, presence: true
       validates :gender, inclusion: { in: GENDERS }
       validates :age, numericality: { greater_than: 0, less_than: 100 }
+      validate :validate_fdp
 
       delegate(:name, to: :beneficiary_category, prefix: true)
+      delegate(:name, to: :fdp, prefix: true)
+
+      def validate_fdp
+        return unless fdp
+
+        errors.add(:fdp, 'should be a valid distribution point.') unless fdp.location_type == Location::FDP
+      end
     end
   end
 end

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

@@ -0,0 +1,11 @@
+module Cats
+  module Core
+    class CashDonation < Donation
+      belongs_to :currency
+
+      validates :amount, presence: true, numericality: { greater_than: 0 }
+
+      delegate(:code, to: :currency, prefix: true)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Cats
+  module Core
+    class CommodityDonation < Donation
+      belongs_to :plan, optional: true
+      belongs_to :commodity_category
+      belongs_to :unit, class_name: 'UnitOfMeasure'
+
+      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)
+      delegate(:abbreviation, to: :unit, prefix: true)
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module Cats
 
         return if dispatchable.status == RhnRequest::APPROVED
 
-        errors.add(:dispatchable, 'is already reserved.') if id.nil?
+        errors.add(:dispatchable, 'is already reserved.') if id.nil? && dispatchable.status == Dispatchable::RESERVED
       end
 
       def approve

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

@@ -1,28 +1,14 @@
 module Cats
   module Core
     class Donation < ApplicationRecord
-      CASH = 'Cash'.freeze
-      KIND = 'Kind'.freeze
-      DONATION_TYPES = [CASH, KIND].freeze
+      self.abstract_class = true
 
       belongs_to :donor
-      belongs_to :plan, optional: true
-      belongs_to :currency, optional: true
-      belongs_to :commodity_category, optional: true
-      belongs_to :unit_of_measure, optional: true
 
-      validates :reference_no, :amount, :donation_type, :donated_on, presence: true
+      validates :reference_no, :donated_on, presence: true
       validates :reference_no, uniqueness: true
-      validates :donation_type, inclusion: { in: DONATION_TYPES }
-      validates :currency, presence: true, if: -> { donation_type == CASH }
-      validates :commodity_category, presence: true, if: -> { donation_type == KIND }
-      validates :unit_of_measure, presence: true, if: -> { donation_type == KIND }
 
       delegate(:name, to: :donor, prefix: true)
-      delegate(:reference_no, to: :plan, prefix: true, allow_nil: true)
-      delegate(:name, to: :commodity_category, prefix: true, allow_nil: true)
-      delegate(:code, to: :currency, prefix: true, allow_nil: true)
-      delegate(:abbreviation, to: :unit_of_measure, prefix: true, allow_nil: true)
     end
   end
 end

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

@@ -3,9 +3,9 @@ module Cats
     class GiftCertificate < ApplicationRecord
       belongs_to :donation, optional: true
       belongs_to :commodity_category
-      belongs_to :unit_of_measure
+      belongs_to :unit, class_name: 'UnitOfMeasure'
       belongs_to :currency
-      belongs_to :destination_warehouse, class_name: 'Cats::Core::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
@@ -13,28 +13,8 @@ module Cats
 
       delegate(:name, to: :commodity_category, prefix: true)
       delegate(:name, to: :destination_warehouse, prefix: true)
-      delegate(:abbreviation, to: :unit_of_measure, prefix: true)
+      delegate(:abbreviation, to: :unit, prefix: true)
       delegate(:code, to: :currency, prefix: true)
-
-      before_validation :set_commodity_category
-      after_create :update_donation
-
-      def update_donation
-        return unless donation
-
-        return if donation.active
-
-        donation.active = true
-        donation.save!
-      end
-
-      def set_commodity_category
-        return unless donation
-
-        return if commodity_category == donation.commodity_category
-
-        self.commodity_category = donation.commodity_category
-      end
     end
   end
 end

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

@@ -0,0 +1,15 @@
+module Cats
+  module Core
+    class Loan < ApplicationRecord
+      belongs_to :commodity_category
+      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 }
+
+      delegate(:name, to: :commodity_category, prefix: true)
+      delegate(:abbreviation, to: :unit, prefix: true)
+    end
+  end
+end

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

@@ -27,6 +27,10 @@ module Cats
       validates :season, presence: true, inclusion: { in: SEASONS }
       validates :reference_no, uniqueness: true
       validates :status, inclusion: { in: STATUSES }
+
+      def no_of_round_days
+        total_days / rounds
+      end
     end
   end
 end

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

@@ -5,27 +5,19 @@ module Cats
       FOREIGN = 'Foreign'.freeze
       PURCHASE_TYPES = [LOCAL, FOREIGN].freeze
 
-      belongs_to :donation
+      belongs_to :cash_donation
       belongs_to :commodity_category
+      belongs_to :currency
       belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
 
-      validates :reference_no, :order_date, :supplier, :quantity, :purchase_type, presence: true
+      validates :reference_no, :order_date, :supplier, :purchase_type, presence: true
       validates :reference_no, uniqueness: true
       validates :purchase_type, inclusion: { in: PURCHASE_TYPES }
-      validates :quantity, numericality: { greater_than: 0 }
+      validates :quantity, :price, presence: true, numericality: { greater_than: 0 }
 
       delegate(:name, to: :commodity_category, prefix: true)
       delegate(:name, to: :unit, prefix: true)
-
-      after_create :update_donation
-
-      def update_donation
-        donation = self.donation
-        return if donation.active
-
-        donation.active = true
-        donation.save!
-      end
+      delegate(:code, to: :currency, prefix: true)
     end
   end
 end

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

@@ -3,11 +3,11 @@ module Cats
     class RhnRequest < ApplicationRecord
       include Dispatchable
 
-      DRAFT = 'Draft'.freeze
-      APPROVED = 'Approved'.freeze
-      RESERVED = 'Reserved'.freeze
+      # DRAFT = 'Draft'.freeze
+      # APPROVED = 'Approved'.freeze
+      # RESERVED = 'Reserved'.freeze
       ALLOCATED = 'Allocated'.freeze
-      STATUSES = [DRAFT, APPROVED, RESERVED, ALLOCATED].freeze
+      STATUSES << ALLOCATED
 
       belongs_to :commodity
 

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

@@ -0,0 +1,16 @@
+module Cats
+  module Core
+    class RoundBeneficiary < ApplicationRecord
+      belongs_to :beneficiary
+      belongs_to :round_plan_item
+      belongs_to :commodity_category
+      belongs_to :unit, class_name: 'UnitOfMeasure'
+
+      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)
+    end
+  end
+end

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

@@ -3,12 +3,9 @@ module Cats
     class RoundPlan < ApplicationRecord
       include Dispatchable
 
-      DRAFT = 'Draft'.freeze
-      APPROVED = 'Approved'.freeze
-      RESERVED = 'Reserved'.freeze
       NEEDS_APPROVED = 'Needs Approved'.freeze
 
-      STATUSES = [DRAFT, APPROVED, RESERVED, NEEDS_APPROVED].freeze
+      STATUSES << NEEDS_APPROVED
 
       belongs_to :plan
       belongs_to :region, class_name: 'Cats::Core::Location'
@@ -17,6 +14,7 @@ module Cats
       has_many :round_rations
       has_many :beneficiary_round_plan_items, through: :round_plan_items
       has_many :round_plan_item_details, through: :beneficiary_round_plan_items
+      has_many :round_beneficiaries, through: :round_plan_items
 
       validates :rounds, presence: true
       validates :reference_no, presence: true, uniqueness: true

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

@@ -10,6 +10,7 @@ module Cats
 
       has_many :beneficiary_round_plan_items
       has_many :round_plan_item_details, through: :beneficiary_round_plan_items
+      has_many :round_beneficiaries
 
       validates :plan_item_id, presence: true
       validates :round_plan_id, uniqueness: { scope: :fdp_id }

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

@@ -0,0 +1,19 @@
+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'
+
+      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 }
+
+      delegate(:name, to: :issued_commodity, prefix: true)
+      delegate(:name, to: :received_commodity, prefix: true)
+      delegate(:abbreviation, to: :issued_unit, prefix: true)
+      delegate(:abbreviation, to: :received_unit, prefix: true)
+    end
+  end
+end

data/app/models/concerns/cats/core/dispatchable.rb

@@ -7,6 +7,14 @@ module Cats
     module Dispatchable
       extend ActiveSupport::Concern
 
+      DRAFT = 'Draft'.freeze
+      APPROVED = 'Approved'.freeze
+      RESERVED = 'Reserved'.freeze
+
+      # rubocop:disable Style/MutableConstant
+      STATUSES = [DRAFT, APPROVED, RESERVED]
+      # rubocop:enable Style/MutableConstant
+
       included do
         has_many :dispatch_plans, as: :dispatchable
       end

data/app/serializers/cats/core/cash_donation_serializer.rb

@@ -0,0 +1,8 @@
+module Cats
+  module Core
+    class CashDonationSerializer < ActiveModel::Serializer
+      attributes :id, :reference_no, :description, :donated_on, :donor_id, :donor_name, :amount, :currency_id,
+                 :currency_code
+    end
+  end
+end

data/app/serializers/cats/core/commodity_donation_serializer.rb

@@ -0,0 +1,9 @@
+module Cats
+  module Core
+    class CommodityDonationSerializer < ActiveModel::Serializer
+      attributes :id, :reference_no, :donated_on, :donor_id, :donor_name, :plan_id, :plan_reference_no,
+                 :quantity, :unit_id, :unit_abbreviation, :description, :commodity_category_id,
+                 :commodity_category_name, :shipping_reference
+    end
+  end
+end

data/app/serializers/cats/core/loan_serializer.rb

@@ -0,0 +1,8 @@
+module Cats
+  module Core
+    class LoanSerializer < ActiveModel::Serializer
+      attributes :id, :reference_no, :lender, :agreement_date, :repayment_date, :commodity_category_id,
+                 :commodity_category_name, :quantity, :unit_id, :unit_abbreviation
+    end
+  end
+end

data/app/serializers/cats/core/purchase_order_serializer.rb

@@ -0,0 +1,9 @@
+module Cats
+  module Core
+    class PurchaseOrderSerializer < ActiveModel::Serializer
+      attributes :id, :reference_no, :order_date, :requisition_no, :supplier, :cash_donation_id, :purchase_type,
+                 :commodity_category_id, :commodity_category_name, :quantity, :unit_id, :unit_name, :currency_id,
+                 :currency_code, :price
+    end
+  end
+end

data/app/serializers/cats/core/round_beneficiary_serializer.rb

@@ -0,0 +1,8 @@
+module Cats
+  module Core
+    class RoundBeneficiarySerializer < ActiveModel::Serializer
+      attributes :id, :beneficiary_id, :beneficiary_full_name, :round_plan_item_id, :commodity_category_id,
+                 :commodity_category_name, :quantity, :unit_id, :unit_abbreviation, :received
+    end
+  end
+end

data/app/serializers/cats/core/swap_serializer.rb

@@ -0,0 +1,9 @@
+module Cats
+  module Core
+    class SwapSerializer < ActiveModel::Serializer
+      attributes :id, :reference_no, :swapper, :agreement_date, :issued_commodity_id, :issued_commodity_name,
+                 :issued_quantity, :received_commodity_id, :received_commodity_name, :received_quantity,
+                 :issued_unit_id, :issued_unit_abbreviation, :received_unit_id, :received_unit_abbreviation
+    end
+  end
+end

data/app/services/cats/core/beneficiary_service.rb

@@ -0,0 +1,87 @@
+module Cats
+  module Core
+    class BeneficiaryService
+      def clear_distribution_list(id)
+        round_plan = RoundPlan.find(id)
+        raise(StandardError, 'Round plan is not in draft state.') unless round_plan.status == RoundPlan::DRAFT
+
+        RoundBeneficiary.joins(:round_plan_item).where(round_plan_item: { round_plan_id: id }).delete_all
+      end
+
+      def generate_distribution_list(id)
+        clear_distribution_list(id)
+        round_plan = RoundPlan.find(id)
+        plan_days = round_plan.plan.no_of_round_days
+        rounds = round_plan.rounds.count
+        beneficiaries = Beneficiary.joins(:beneficiary_category).where(
+          beneficiary_category: { plan_id: round_plan.plan_id }
+        ).group_by(&:fdp_id)
+        beneficiaries.each_key do |key|
+          beneficiaries[key] = beneficiaries[key].group_by(&:beneficiary_category_id)
+        end
+        rations = round_plan.round_rations
+
+        round_beneficiaries = []
+        round_plan.round_plan_items.each do |rpi|
+          fdp_beneficiaries = beneficiaries[rpi.fdp_id]
+          fdp_beneficiaries.each_key do |key|
+            category_rations = rations.select { |r| r.beneficiary_category_id == key }
+            category_rations.each do |ration|
+              fdp_beneficiaries[key].each do |beneficiary|
+                round_beneficiaries << {
+                  beneficiary_id: beneficiary.id,
+                  round_plan_item_id: rpi.id,
+                  commodity_category_id: ration.commodity_category_id,
+                  quantity: plan_days / ration.no_of_days * ration.quantity * rounds,
+                  unit_id: ration.unit_of_measure_id,
+                  received: false
+                }
+              end
+            end
+          end
+        end
+
+        RoundBeneficiary.insert_all!(round_beneficiaries, record_timestamps: true)
+        true
+      end
+
+      def remove_items(plan_id, ids)
+        raise(StandardError, 'No beneficiaries specified.') if ids.count.zero?
+
+        begin
+          plan = RoundPlan.find(plan_id)
+        rescue ActiveRecord::RecordNotFound
+          raise(StandardError, 'Round plan not found.') unless plan
+        end
+
+        beneficiaries = RoundBeneficiary.joins(:round_plan_item)
+                                        .where(round_plan_item: { round_plan_id: plan_id })
+        to_delete = RoundBeneficiary.where(id: ids)
+        diff = to_delete - beneficiaries
+        raise(StandardError, 'Round plan beneficiaries should be from the same plan.') if diff.count.positive?
+
+        to_delete.delete_all
+        true
+      end
+
+      def confirm_receipt(plan_id, ids)
+        raise(StandardError, 'No beneficiaries specified.') if ids.count.zero?
+
+        begin
+          plan = RoundPlan.find(plan_id)
+        rescue ActiveRecord::RecordNotFound
+          raise(StandardError, 'Round plan not found.') unless plan
+        end
+
+        beneficiaries = RoundBeneficiary.joins(:round_plan_item)
+                                        .where(round_plan_item: { round_plan_id: plan_id })
+        to_confirm = RoundBeneficiary.where(id: ids)
+        diff = to_confirm - beneficiaries
+        raise(StandardError, 'Round plan beneficiaries should be from the same plan.') if diff.count.positive?
+
+        to_confirm.update_all(received: true)
+        true
+      end
+    end
+  end
+end