cats_core 1.4.12 → 1.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3724badb244476dc73d7c35fac9971114160be9781ba3a386f2d35ef70226324
-  data.tar.gz: 9f29cd5757d75472e03f8baa3bd4421fc78109d50612955ebdd666a354c17ca6
+  metadata.gz: 52e2769c0f1f85fdbaa5eafafebec437ce3dede1db72a3781ebd5502a8f521b0
+  data.tar.gz: e25329c1ee2367d96fe7ef3282f56a7ed60ff9bef55dd6d31e9ffe06143a4950
 SHA512:
-  metadata.gz: e5a859815e6420692ab833b54372ae47c0fbf835b8384c8d18421eadb79125deb3a2c91ae740dfb9abe1817bf7e01e45cc14312e94d95aaadaade3e767a64dfe
-  data.tar.gz: a85113ab315551f8684accc9d21345b684d9762c73bfc44538bf6d8ac30a4d8e1f2aea24620fc0ebdee000f97de0ae18745b72a28a68cb6f44f6e3b9b184b209
+  metadata.gz: 4feab6c3d42233222cdc473353c43a36683a2574d1ebad9d6980b98cf6caa405c8961e6b2e358f916c775d3fc88861b1702dc9381f51c574114afd1f46131023
+  data.tar.gz: 5435ee907031fa3421a02c2e22e06cde93fe39ebf9cc81cb76e22c1b0de83a8dda97a7c0b9555a11fab1439407d293f48867f9ecdd2e5532f4e79516929d38ae

data/app/controllers/cats/core/{monthly_plans_controller.rb → round_plans_controller.rb}

@@ -1,23 +1,23 @@
 module Cats
   module Core
-    class MonthlyPlansController < ApplicationController
+    class RoundPlansController < ApplicationController
       include Common
 
-      before_action :set_service, only: %i[generate remove_items generate_monthly_needs]
+      before_action :set_service, only: %i[generate remove_items generate_round_needs]
 
       def index
         super do
-          MonthlyPlan.where(plan: params[:id])
+          RoundPlan.where(plan: params[:id])
         end
       end
 
       def filter
-        query = MonthlyPlan.ransack(params[:q])
+        query = RoundPlan.ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 
       def approve
-        plan = MonthlyPlan.find(params[:id])
+        plan = RoundPlan.find(params[:id])
         plan.approve
         render json: { success: true, data: serialize(plan) }
       rescue StandardError => e
@@ -25,12 +25,13 @@ module Cats
       end
 
       def generate
-        plan = @service.generate_monthly_plan(model_params)
+        p = model_params
+        plan = @service.generate_round_plan(p[:reference_no], p[:rounds], p[:plan_id], p[:region_id])
         render json: { success: true, data: serialize(plan) }
       end
 
-      def generate_monthly_needs
-        plan = @service.generate_monthly_needs(params[:id])
+      def generate_round_needs
+        plan = @service.generate_round_needs(params[:id])
         render json: { success: true, data: serialize(plan) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
@@ -46,11 +47,11 @@ module Cats
       private
 
       def model_params
-        params.require(:payload).permit(:reference_no, :status, :plan_id, :region_id, :month, :no_of_days)
+        params.require(:payload).permit(:reference_no, :status, :plan_id, :region_id, rounds: [])
       end
 
       def set_service
-        @service = MonthlyPlanService.new
+        @service = RoundPlanService.new
       end
 
       def remove_params

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

@@ -0,0 +1,15 @@
+module Cats
+  module Core
+    class Beneficiary < ApplicationRecord
+      MALE = 'M'.freeze
+      FEMALE = 'F'.freeze
+      GENDERS = [MALE, FEMALE].freeze
+
+      belongs_to :beneficiary_category
+
+      validates :full_name, :age, :gender, presence: true
+      validates :gender, inclusion: { in: GENDERS }
+      validates :age, numericality: { greater_than: 0, less_than: 100 }
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Cats
+  module Core
+    class BeneficiaryCategory < ApplicationRecord
+      belongs_to :plan
+      has_many :rations
+
+      validates :code, :name, presence: true
+      validates :code, uniqueness: true
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Cats
+  module Core
+    class BeneficiaryPlanItem < ApplicationRecord
+      belongs_to :plan_item
+      belongs_to :beneficiary_category
+      has_many :plan_item_details
+
+      validates :beneficiaries, presence: true, numericality: { greater_than: 0 }
+      validates :plan_item_id, uniqueness: { scope: :beneficiary_category_id }
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Cats
+  module Core
+    class BeneficiaryRoundPlanItem < ApplicationRecord
+      belongs_to :round_plan_item
+      belongs_to :beneficiary_category
+      has_many :round_plan_item_details
+
+      validates :beneficiaries, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :round_plan_item_id, uniqueness: { scope: :beneficiary_category_id }
+
+      delegate(:name, to: :beneficiary_category, prefix: true)
+    end
+  end
+end

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

@@ -13,9 +13,12 @@ module Cats
       SEASONS = [BELG, MEHER, ANNUAL].freeze
 
       belongs_to :program
-      belongs_to :ration, optional: true
+      has_many :beneficiary_categories
+      has_many :rations, through: :beneficiary_categories
       has_many :plan_items
-      has_many :plan_item_details, through: :plan_items
+      has_many :round_plans
+      has_many :beneficiary_plan_items, through: :plan_items
+      has_many :plan_item_details, through: :beneficiary_plan_items
 
       validates :reference_no, :year, :status, presence: true
       validates :total_days, :rounds, presence: true, numericality: { greater_than: 0 }

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

@@ -2,15 +2,22 @@ module Cats
   module Core
     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 :operator
 
-      has_many :plan_item_details
+      has_many :beneficiary_plan_items
+      has_many :plan_item_details, through: :beneficiary_plan_items
 
-      validates :beneficiaries, presence: true, numericality: { greater_than: 0 }
-      validates :plan_id, uniqueness: { scope: :woreda_id }
+      validates :plan_id, uniqueness: { scope: :fdp_id }
 
+      delegate(:name, to: :region, prefix: true)
+      delegate(:name, to: :zone, prefix: true)
       delegate(:name, to: :woreda, prefix: true)
+      delegate(:name, to: :fdp, prefix: true)
       delegate(:name, to: :operator, prefix: true)
     end
   end

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

@@ -1,11 +1,11 @@
 module Cats
   module Core
     class PlanItemDetail < ApplicationRecord
-      belongs_to :plan_item
-      belongs_to :ration_item
+      belongs_to :beneficiary_plan_item
+      belongs_to :ration
 
-      validates :amount, presence: true, numericality: { greater_than: 0 }
-      validates :plan_item_id, uniqueness: { scope: :ration_item_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/ration.rb

@@ -1,9 +1,15 @@
 module Cats
   module Core
     class Ration < ApplicationRecord
-      belongs_to :program
+      belongs_to :beneficiary_category
+      belongs_to :commodity_category
+      belongs_to :unit_of_measure
 
       validates :reference_no, presence: true, uniqueness: true
+      validates :quantity, :no_of_days, presence: true, numericality: { greater_than: 0 }
+
+      delegate(:name, to: :commodity_category, prefix: true)
+      delegate(:abbreviation, to: :unit_of_measure, prefix: true)
     end
   end
 end

data/app/models/cats/core/{monthly_plan.rb → round_plan.rb}

@@ -1,6 +1,6 @@
 module Cats
   module Core
-    class MonthlyPlan < ApplicationRecord
+    class RoundPlan < ApplicationRecord
       include Dispatchable
 
       DRAFT = 'Draft'.freeze
@@ -13,14 +13,16 @@ module Cats
       belongs_to :plan
       belongs_to :region, class_name: 'Cats::Core::Location'
 
-      has_many :monthly_plan_items
-      has_many :monthly_plan_item_details, through: :monthly_plan_items
-      has_many :monthly_rations
+      has_many :round_plan_items
+      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
 
+      validates :rounds, presence: true
       validates :reference_no, presence: true, uniqueness: true
-      validates :status, presence: true, inclusion: { in: MonthlyPlan::STATUSES }
-      validates :no_of_days, :month, presence: true, numericality: { greater_than: 0 }
-      validate :validate_month, :validate_region
+      validates :status, presence: true, inclusion: { in: RoundPlan::STATUSES }
+      validate :validate_region
+      validate :validate_rounds, on: :create
 
       delegate(:reference_no, to: :plan, prefix: true)
       delegate(:name, to: :region, prefix: true)
@@ -36,7 +38,7 @@ module Cats
       def approve
         raise(StandardError, 'Plan is not in draft state.') unless status == DRAFT
 
-        raise(StandardError, 'Empty plan cannot be approved.') if monthly_plan_items.count.zero?
+        raise(StandardError, 'Empty plan cannot be approved.') if round_plan_items.count.zero?
 
         update!(status: APPROVED)
       end
@@ -48,10 +50,19 @@ module Cats
         save!
       end
 
-      def validate_month
-        return unless month
+      def validate_rounds
+        return unless rounds && plan
 
-        errors.add(:month, 'cannot be greater than 12.') if month > 12
+        errors.add(:rounds, 'cannot be an empty list') if rounds.length.zero?
+
+        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.')
+            break
+          end
+        end
+        errors.add(:rounds, 'cannot be repeated.') unless existing_rounds - rounds == existing_rounds
       end
 
       def validate_region

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

@@ -0,0 +1,25 @@
+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 :operator
+
+      has_many :beneficiary_round_plan_items
+      has_many :round_plan_item_details, through: :beneficiary_round_plan_items
+
+      validates :plan_item_id, presence: true
+      validates :round_plan_id, uniqueness: { scope: :fdp_id }
+
+      delegate(:reference_no, to: :round_plan, prefix: true)
+      delegate(:name, to: :region, prefix: true)
+      delegate(:name, to: :zone, prefix: true)
+      delegate(:name, to: :woreda, prefix: true)
+      delegate(:name, to: :fdp, prefix: true)
+      delegate(:name, to: :operator, prefix: true)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Cats
+  module Core
+    class RoundPlanItemDetail < ApplicationRecord
+      belongs_to :beneficiary_round_plan_item
+      belongs_to :round_ration
+
+      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validates :beneficiary_round_plan_item_id, uniqueness: { scope: :round_ration_id }
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Cats
+  module Core
+    class RoundRation < ApplicationRecord
+      belongs_to :beneficiary_category
+      belongs_to :commodity_category
+      belongs_to :unit_of_measure
+      belongs_to :round_plan
+
+      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)
+      delegate(:abbreviation, to: :unit_of_measure, prefix: true)
+      delegate(:reference_no, to: :round_plan, prefix: true)
+    end
+  end
+end

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

@@ -9,10 +9,16 @@ module Cats
       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 :order_date, presence: true
       validate :validate_against_requisition
 
+      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')
+
       def validate_against_requisition
         return unless transport_requisition
 

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

@@ -11,6 +11,9 @@ module Cats
       validates :transport_requisition_item_id, uniqueness: true
       validate :validate_requisition
 
+      delegate(:name, to: :transporter, prefix: true)
+      delegate(:contract_no, to: :transport_contract, prefix: false)
+
       def validate_requisition
         return unless transport_requisition_item
 

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

@@ -0,0 +1,7 @@
+module Cats
+  module Core
+    class RoundPlanSerializer < ActiveModel::Serializer
+      attributes :id, :reference_no, :status, :plan_id, :plan_reference_no, :region_id, :region_name, :rounds
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Cats
+  module Core
+    class RoundPlanService
+      def generate_round_needs(plan_id)
+        round_plan = Cats::Core::RoundPlan.find(plan_id)
+        raise(StandardError, 'Plan has no rations.') if round_plan.round_rations.count.zero?
+
+        raise(StandardError, 'Plan has no plan items.') if round_plan.round_plan_items.count.zero?
+
+        round_plan.round_plan_item_details.delete_all if round_plan.round_plan_item_details.count.positive?
+
+        details = []
+        rations = round_plan.round_rations
+        plan = round_plan.plan
+        no_of_days = plan.total_days / plan.rounds
+        round_plan.beneficiary_round_plan_items.each do |plan_item|
+          round_rations = rations.select { |r| r.beneficiary_category_id == plan_item.beneficiary_category_id }
+          round_rations.each do |ration|
+            details << {
+              beneficiary_round_plan_item_id: plan_item.id,
+              round_ration_id: ration.id,
+              quantity: (
+                (no_of_days / ration.no_of_days * ration.quantity) *
+                plan_item.beneficiaries *
+                round_plan.rounds.count
+              )
+            }
+          end
+        end
+
+        Cats::Core::RoundPlanItemDetail.insert_all!(details)
+        round_plan
+      end
+
+      def generate_round_plan(reference_no, rounds, plan_id, region_id)
+        round_plan = Cats::Core::RoundPlan.create!(
+          plan_id: plan_id,
+          reference_no: reference_no,
+          region_id: region_id,
+          status: Cats::Core::Plan::DRAFT,
+          rounds: rounds
+        )
+        rations = Cats::Core::Ration.joins(:beneficiary_category).where(beneficiary_category: { plan_id: plan_id })
+        round_rations = rations.map do |ration|
+          {
+            beneficiary_category_id: ration.beneficiary_category_id,
+            commodity_category_id: ration.commodity_category_id,
+            quantity: ration.quantity,
+            unit_of_measure_id: ration.unit_of_measure_id,
+            round_plan_id: round_plan.id,
+            no_of_days: ration.no_of_days,
+            created_at: Date.today,
+            updated_at: Date.today
+          }
+        end
+        Cats::Core::RoundRation.insert_all!(round_rations)
+        plan_items = Cats::Core::PlanItem.where(plan_id: plan_id, region_id: region_id)
+        ben_plan_items = Cats::Core::BeneficiaryPlanItem.where(plan_item: plan_items)
+        round_plan_items = plan_items.map do |plan_item|
+          {
+            round_plan_id: round_plan.id,
+            region_id: region_id,
+            zone_id: plan_item.zone_id,
+            woreda_id: plan_item.woreda_id,
+            fdp_id: plan_item.fdp_id,
+            operator_id: plan_item.operator_id,
+            plan_item_id: plan_item.id
+          }
+        end
+        result = Cats::Core::RoundPlanItem.insert_all!(
+          round_plan_items,
+          returning: %w[id plan_item_id],
+          record_timestamps: true
+        )
+        rows = result.rows
+        ben_round_plan_items = ben_plan_items.map do |ben_plan_item|
+          item = rows.find { |r| r[1] == ben_plan_item.plan_item_id }
+          {
+            round_plan_item_id: item[0],
+            beneficiary_category_id: ben_plan_item.beneficiary_category_id,
+            planned_beneficiaries: ben_plan_item.beneficiaries,
+            beneficiaries: ben_plan_item.beneficiaries
+          }
+        end
+        Cats::Core::BeneficiaryRoundPlanItem.insert_all!(ben_round_plan_items, record_timestamps: true)
+        round_plan
+      end
+
+      def remove_items(plan_id, ids)
+        raise(StandardError, 'No plan items specified.') if ids.count.zero?
+
+        begin
+          plan = Cats::Core::RoundPlan.find(plan_id)
+        rescue ActiveRecord::RecordNotFound
+          raise(StandardError, 'Round plan not found.') unless plan
+        end
+
+        plans = Cats::Core::RoundPlan.includes(:round_plan_items).where(round_plan_items: { id: ids })
+        raise(StandardError, 'Plan items should be from the same plan.') if plans.count > 1
+
+        raise(StandardError, 'Items are not from the given round plan.') unless plan_id == plans[0].id
+
+        Cats::Core::RoundPlanItem.delete_by(id: ids)
+        plan
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -124,13 +124,13 @@ Cats::Core::Engine.routes.draw do
   end
   resources :receipt_transactions, except: %i[index new edit destroy]
   resources :lost_commodities, except: %i[index destroy]
-  get '/plans/:id/monthly_plans', controller: :monthly_plans, action: :index, as: :monthly_plans_plan
-  post '/monthly_plans/generate'
-  post '/monthly_plans/filter'
-  resources :monthly_plans, except: %i[index destroy] do
+  get '/plans/:id/round_plans', controller: :round_plans, action: :index, as: :round_plans_plan
+  post '/round_plans/generate'
+  post '/round_plans/filter'
+  resources :round_plans, except: %i[index destroy] do
     member do
       post 'remove_items'
-      post 'generate_monthly_needs'
+      post 'generate_round_needs'
       post 'approve'
     end
   end

data/db/migrate/20210717031810_create_cats_core_plans.rb

@@ -13,10 +13,6 @@ class CreateCatsCorePlans < ActiveRecord::Migration[6.1]
                    null: false,
                    index: { name: 'program_on_plan_indx' },
                    foreign_key: { to_table: :cats_core_programs }
-      t.references :ration,
-                   null: true,
-                   index: { name: 'ration_on_plan_indx' },
-                   foreign_key: { to_table: :cats_core_rations }
 
       t.timestamps
     end

data/db/migrate/20210717032024_create_cats_core_plan_items.rb

@@ -5,11 +5,22 @@ class CreateCatsCorePlanItems < ActiveRecord::Migration[6.1]
                    null: false,
                    index: { name: 'plan_on_plan_items_indx' },
                    foreign_key: { to_table: :cats_core_plans }
+      t.references :region,
+                   null: false,
+                   index: { name: 'region_on_plan_items_indx' },
+                   foreign_key: { to_table: :cats_core_locations }
+      t.references :zone,
+                   null: false,
+                   index: { name: 'zone_on_plan_items_indx' },
+                   foreign_key: { to_table: :cats_core_locations } 
       t.references :woreda,
                    null: false,
                    index: { name: 'woreda_on_plan_items_idnx' },
                    foreign_key: { to_table: :cats_core_locations }
-      t.integer :beneficiaries, null: false
+      t.references :fdp,
+                   null: false,
+                   index: { name: 'fdp_on_plan_items_indx' },
+                   foreign_key: { to_table: :cats_core_locations } 
       t.references :operator,
                    null: false,
                    index: { name: 'operator_on_plan_items_indx' },
@@ -18,6 +29,6 @@ class CreateCatsCorePlanItems < ActiveRecord::Migration[6.1]
       t.timestamps
     end
 
-    add_index :cats_core_plan_items, [:plan_id, :woreda_id], unique: true
+    add_index :cats_core_plan_items, [:plan_id, :fdp_id], unique: true
   end
 end

data/db/migrate/20210717032260_create_cats_core_beneficiary_categories.rb

@@ -0,0 +1,14 @@
+class CreateCatsCoreBeneficiaryCategories < ActiveRecord::Migration[7.0]
+  def change
+    create_table :cats_core_beneficiary_categories do |t|
+      t.string :code, unique: true
+      t.string :name, null: false
+      t.references :plan,
+                   null: false,
+                   index: { name: 'plan_on_bc_indx' },
+                   foreign_key: { to_table: :cats_core_plans }
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/{20210717031343_create_cats_core_ration_items.rb → 20210717032270_create_cats_core_rations.rb}

@@ -1,21 +1,22 @@
-class CreateCatsCoreRationItems < ActiveRecord::Migration[6.1]
+class CreateCatsCoreRations < ActiveRecord::Migration[6.1]
   def change
-    create_table :cats_core_ration_items do |t|
+    create_table :cats_core_rations do |t|
+      t.string :reference_no, unique: true
+      t.references :beneficiary_category,
+                   null: false,
+                   index: { name: 'bc_on_ration_indx' },
+                   foreign_key: { to_table: :cats_core_beneficiary_categories }
       t.references :commodity_category,
                    null: false,
                    index: { name: 'cc_on_ration_indx' },
                    foreign_key: { to_table: :cats_core_commodity_categories }
-      t.references :ration,
-                   null: false,
-                   index: { name: 'ri_on_ration_indx' },
-                   foreign_key: { to_table: :cats_core_rations }
       t.references :unit_of_measure,
                    null: false,
                    index: { name: 'uom_on_ration_indx' },
                    foreign_key: { to_table: :cats_core_unit_of_measures }
-      t.float :amount, null: false
+      t.float :quantity, null: false
       t.integer :no_of_days, null: false
-
+      
       t.timestamps
     end
   end

data/db/migrate/20210717032290_create_cats_core_beneficiary_plan_items.rb

@@ -0,0 +1,23 @@
+class CreateCatsCoreBeneficiaryPlanItems < ActiveRecord::Migration[7.0]
+  def change
+    create_table :cats_core_beneficiary_plan_items do |t|
+      t.references :plan_item,
+                   null: false,
+                   index: { name: 'pi_on_bpi_indx' },
+                   foreign_key: { to_table: :cats_core_plan_items }
+      t.references :beneficiary_category,
+                   null: false,
+                   index: { name: 'bc_on_bpi_indx' },
+                   foreign_key: { to_table: :cats_core_beneficiary_categories }
+      t.integer :beneficiaries, null: false
+
+      t.timestamps
+    end
+    add_index(
+      :cats_core_beneficiary_plan_items,
+      [:plan_item_id, :beneficiary_category_id],
+      unique: true,
+      name: 'pii_on_bci_uniq_indx'
+    )
+  end
+end

data/db/migrate/20210717032295_create_cats_core_plan_item_details.rb

@@ -0,0 +1,18 @@
+class CreateCatsCorePlanItemDetails < ActiveRecord::Migration[6.1]
+  def change
+    create_table :cats_core_plan_item_details do |t|
+      t.references :beneficiary_plan_item,
+                   null: false,
+                   index: { name: 'bpi_on_pid_indx' },
+                   foreign_key: { to_table: :cats_core_beneficiary_plan_items }
+      t.references :ration,
+                   null: false,
+                   index: { name: 'ration_on_pid_indx' },
+                   foreign_key: { to_table: :cats_core_rations }
+      t.float :quantity, null: false
+
+      t.timestamps
+    end
+    add_index(:cats_core_plan_item_details, [:beneficiary_plan_item_id, :ration_id], unique: true, name: 'bpii_ri_on_pid_indx')
+  end
+end

data/db/migrate/{20220107121752_create_cats_core_monthly_plans.rb → 20220107121752_create_cats_core_round_plans.rb}

@@ -1,9 +1,8 @@
-class CreateCatsCoreMonthlyPlans < ActiveRecord::Migration[6.1]
+class CreateCatsCoreRoundPlans < ActiveRecord::Migration[6.1]
   def change
-    create_table :cats_core_monthly_plans do |t|
+    create_table :cats_core_round_plans do |t|
       t.string :reference_no, unique: true
-      t.integer :month, null: false
-      t.integer :no_of_days, null: false
+      t.integer :rounds, array: true, default: []
       t.string :status, null: false, default: 'Draft'
       t.references :plan,
                    null: false,