cats_core 1.3.36 → 1.3.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7d2738616bb04e122c03cb503fe91bb1d8cb818c2ef909516d2e506efcad01c
-  data.tar.gz: 7363415368111fa228b7d552f030bdce90009940c62365a27b9408d29745a21b
+  metadata.gz: 16a8d6fe8ce3bada8611add7e2b8669608072f40609445223966652619c16844
+  data.tar.gz: 291b4d451c1027375e203245717680ae5419306ef01707c40abdb66d3ec880c0
 SHA512:
-  metadata.gz: c04a0d21b349fe67c2367204df7dc876bd0ec250753124873583b387f035fe1290a7bb503f8aad9184dd8df6fddd787aaa785fd0f1e281e12c4b0f2a6320871f
-  data.tar.gz: d0104ee1c25f2fa50e196c0daa671c30fbed484cb370116919bc01403e68d736595a0ab17c83f2b2f0921bff87d319840035f99ee6cfd3d20c55d93817a29595
+  metadata.gz: eab2450cce0646b1914dc800938af63f96eea3439c8377a35c2eaef56574d970dcaded1c250b9bf1d59be929b7a428fce9a790f3956adeab6461f0ec94074ffd
+  data.tar.gz: 663adc2701e5fc8a374eb037b66fba8116049f2c49b5d7a7d09640de12b90d55150387db85113f5a6a047792f24a098a83918ab48a0898e32f6a782cb314e1ba

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

@@ -0,0 +1,41 @@
+module Cats
+  module Core
+    class CommoditiesController < ApplicationController
+      include Common
+
+      def approve
+        commodity = Cats::Core::Commodity.find(params[:id])
+        result = commodity.approve
+        render json: { success: result, data: serialize(commodity) }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      def update
+        if @obj.status == Cats::Core::Commodity::APPROVED
+          render json: { success: false, error: 'An approved record cannot be edited.' }
+          return
+        end
+
+        if @obj.update(model_params)
+          render json: { success: true, data: serialize(@obj) }
+        else
+          render json: { success: false, error: @obj.errors.full_messages[0] }, status: :unprocessable_entity
+        end
+      end
+
+      def filter
+        query = Cats::Core::Commodity.ransack(params[:q])
+        render json: { success: true, data: serialize(query.result) }
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:batch_no, :description, :unit_of_measure_id, :source_id,
+                                        :source_type, :quantity, :best_use_before, :volume_per_metric_ton,
+                                        :arrival_status)
+      end
+    end
+  end
+end

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

@@ -8,6 +8,11 @@ module Cats
         render json: { success: true, data: serialize(items) }
       end
 
+      def filter
+        query = Cats::Core::DispatchPlanItem.ransack(params[:q])
+        render json: { success: true, data: serialize(query.result) }
+      end
+
       private
 
       def model_params

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

@@ -4,14 +4,34 @@ module Cats
       include Common
 
       def index
-        transactions = Cats::Core::DispatchTransaction.where(destination_id: params[:id])
+        transactions = Cats::Core::DispatchTransaction.where(dispatch_id: params[:id])
         render json: { success: true, data: serialize(transactions) }
       end
 
+      # This end-point is used to create upstream dispatch transactions.
+      # We need a specific method like this because for upstream the source
+      # stack is a dummy one and we need to use that without waiting for the
+      # user to give us a source.
+      def create_allocation
+        dispatch = Dispatch.find(model_params[:dispatch_id])
+        commodity = dispatch.dispatch_plan_item.dispatch_plan.commodity
+        transaction = DispatchTransaction.new(model_params)
+
+        # Fetch supplier stack by commodity
+        stack = Stack.joins(:store).find_by(commodity: commodity, store: { code: 'SUP-STORE' })
+        transaction.source = stack
+
+        if transaction.save
+          render json: { success: true, data: serialize(transaction) }, status: :created
+        else
+          render json: { success: false, error: transaction.errors.full_messages[0] }, status: :unprocessable_entity
+        end
+      end
+
       private
 
       def model_params
-        params.require(:payload).permit(:source_id, :destination_id, :transaction_date, :quantity)
+        params.require(:payload).permit(:source_id, :dispatch_id, :transaction_date, :quantity)
       end
     end
   end

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

@@ -22,14 +22,6 @@ module Cats
         end
       end
 
-      def create_receipt_authorization
-        item = Cats::Core::DispatchPlanItem.find(params[:id])
-        dispatch = @service.create_receipt_authorization(
-          params[:reference_no], item, params[:quantity], params[:remark], current_user
-        )
-        render json: { success: true, data: serialize(dispatch) }
-      end
-
       def approve
         @dispatch.approve
         render json: { success: true, data: serialize(@dispatch) }

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

@@ -4,12 +4,12 @@ module Cats
       include Common
 
       def index
-        data = LostCommodity.where(receipt_id: params[:id])
+        data = LostCommodity.where(dispatch_id: params[:id])
         render json: { success: true, data: serialize(data) }
       end
 
       def model_params
-        params.require(:payload).permit(:receipt_id, :quantity, :commodity_status, :remark)
+        params.require(:payload).permit(:dispatch_id, :quantity, :commodity_status, :remark)
       end
     end
   end

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

@@ -0,0 +1,62 @@
+module Cats
+  module Core
+    class MonthlyPlansController < ApplicationController
+      include Common
+
+      before_action :set_service, only: %i[generate remove_items generate_monthly_needs]
+
+      def index
+        plans = Cats::Core::MonthlyPlan.where(plan: params[:id])
+        render json: { success: true, data: serialize(plans) }
+      end
+
+      def filter
+        query = Cats::Core::MonthlyPlan.ransack(params[:q])
+        render json: { success: true, data: serialize(query.result) }
+      end
+
+      def approve
+        plan = Cats::Core::MonthlyPlan.find(params[:id])
+        if plan.monthly_plan_items.count.zero?
+          render json: { success: false, error: 'Empty plan cannot be approved.' }, status: :unprocessable_entity
+          return
+        end
+        plan.update(status: Cats::Core::Plan::APPROVED)
+        render json: { success: true, data: serialize(plan) }
+      end
+
+      def generate
+        plan = @service.generate_monthly_plan(model_params)
+        render json: { success: true, data: serialize(plan) }
+      end
+
+      def generate_monthly_needs
+        plan = @service.generate_monthly_needs(params[:id])
+        render json: { success: true, data: serialize(plan) }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      def remove_items
+        plan = @service.remove_items(params[:id], remove_params)
+        render json: { success: true, data: serialize(plan) }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:reference_no, :status, :plan_id, :region_id, :month, :no_of_days)
+      end
+
+      def set_service
+        @service = MonthlyPlanService.new
+      end
+
+      def remove_params
+        params.permit(ids: [])
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Cats
       include Common
 
       def index
-        transactions = Cats::Core::ReceiptTransaction.where(source_id: params[:id])
+        transactions = Cats::Core::ReceiptTransaction.where(receipt_id: params[:id])
         render json: { success: true, data: serialize(transactions) }
       end
 
@@ -13,7 +13,7 @@ module Cats
 
         # Look for a transaction with the same destination as incoming
         transaction = Cats::Core::ReceiptTransaction.find_by(
-          source_id: p[:source_id],
+          receipt_id: p[:receipt_id],
           destination_id: p[:destination_id]
         )
         if transaction
@@ -32,7 +32,7 @@ module Cats
       private
 
       def model_params
-        params.require(:payload).permit(:source_id, :destination_id, :transaction_date, :quantity)
+        params.require(:payload).permit(:receipt_id, :destination_id, :transaction_date, :quantity)
       end
     end
   end

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

@@ -9,26 +9,16 @@ module Cats
       end
 
       def create
-        p = model_params
-        receipt = Cats::Core::Receipt.find_by(
-          dispatch_id: p[:dispatch_id],
-          commodity_status: p[:commodity_status]
-        )
-        if receipt
-          receipt.quantity += p[:quantity]
-          if receipt.save
-            render json: { success: true, data: serialize(receipt) }
-          else
-            render json: { success: false, error: receipt.errors.full_messages[0] }, status: :unprocessable_entity
-          end
+        service = ReceiptService.new
+        receipt = service.init(model_params)
+
+        if receipt.save
+          render json: { success: true, data: serialize(receipt) }
         else
-          obj = Cats::Core::Receipt.new(model_params)
-          if obj.save
-            render json: { success: true, data: serialize(obj) }, status: :created
-          else
-            render json: { success: false, error: obj.errors.full_messages[0] }, status: :unprocessable_entity
-          end
+          render json: { success: false, error: receipt.errors.full_messages[0] }, status: :unprocessable_entity
         end
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
       end
 
       def start_stacking

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

@@ -0,0 +1,37 @@
+module Cats
+  module Core
+    class StacksController < ApplicationController
+      include Common
+
+      def index
+        stacks = Stack.where(store_id: params[:id])
+        render json: { success: true, data: serialize(stacks) }
+      end
+
+      def filter
+        query = Stack.where(store_id: params[:id]).ransack(params[:q])
+        render json: { success: true, data: serialize(query.result) }
+      end
+
+      def commodity_for_location
+        service = StackService.new
+        commodities = service.commodity_for_location(current_user)
+        render json: { success: true, data: serialize(commodities) }
+      end
+
+      def receipt_stacks
+        service = StackService.new
+        receipt = Receipt.find(params[:id])
+        stacks = service.receipt_stacks(receipt)
+        render json: { success: true, data: serialize(stacks) }
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:code, :length, :width, :height, :start_x, :start_y, :commodity_id, :store_id,
+                                        :commodity_status, :stack_status, :quantity)
+      end
+    end
+  end
+end

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

@@ -3,6 +3,11 @@ module Cats
     class TransportersController < ApplicationController
       include Cats::Core::Common
 
+      def filter
+        query = Cats::Core::Transporter.ransack(params[:q])
+        render json: { success: true, data: serialize(query.result) }
+      end
+
       private
 
       def model_params

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

@@ -14,17 +14,23 @@ module Cats
       belongs_to :transporter
       belongs_to :dispatch_plan_item
       has_many :receipts
+      has_many :dispatch_transactions
+      has_many :lost_commodities
 
       validates :reference_no, :plate_no, :driver_name, :driver_phone, :quantity, :commodity_status, presence: true
       validates :dispatch_status, presence: true, inclusion: { in: DISPATCH_STATUSES }
       validates :reference_no, uniqueness: true
-      validates :quantity, numericality: { greater_than: 0 }
+      validates :quantity, numericality: { greater_than_or_equal_to: 0 }
       validates :commodity_status, inclusion: { in: Cats::Core::Commodity::COMMODITY_STATUSES }
       validate :validate_quantity, :validate_dispatch_plan_status
 
       delegate(:name, to: :transporter, prefix: true)
       delegate(:email, to: :prepared_by, prefix: true)
 
+      def total_quantity
+        dispatch_transactions.sum(:quantity)
+      end
+
       def validate_quantity
         return unless quantity && dispatch_plan_item
 
@@ -46,14 +52,16 @@ module Cats
       def approve
         raise(StandardError, 'Dispatch has to be in draft state.') unless dispatch_status == Dispatch::DRAFT
 
-        count = DispatchTransaction.where(destination_id: id).count
-        raise(StandardError, 'Dispatch has no transactions.') unless count.positive?
+        # Check if dispatch has transactions
+        raise(StandardError, 'Dispatch has no transactions.') unless dispatch_transactions.count.positive?
 
-        quantity = DispatchTransaction.where(destination_id: id).sum(:quantity)
-        raise(StandardError, 'Transactions quantity is not equal to dispatch quantity.') if self.quantity != quantity
-
-        self.dispatch_status = Dispatch::APPROVED
-        save!
+        Dispatch.transaction do
+          # Commit transactions
+          dispatch_transactions.each(&:commit)
+          self.quantity = total_quantity
+          self.dispatch_status = Dispatch::APPROVED
+          save!
+        end
       end
 
       def start
@@ -61,8 +69,6 @@ module Cats
 
         self.dispatch_status = Dispatch::STARTED
         save!
-        transactions = DispatchTransaction.where(destination_id: id)
-        transactions.each(&:commit)
       end
 
       def confirm

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

@@ -2,15 +2,16 @@ module Cats
   module Core
     class DispatchTransaction < Transaction
       belongs_to :source, class_name: 'Cats::Core::Stack'
-      belongs_to :destination, class_name: 'Cats::Core::Dispatch'
+      belongs_to :dispatch
 
       delegate(:code, to: :source, prefix: true)
-      delegate(:reference_no, to: :destination, prefix: true)
+      delegate(:reference_no, to: :dispatch, prefix: true)
 
       def commit
         Transaction.transaction do
           source.quantity -= quantity
           source.save!
+
           self.status = COMMITTED
           save!
         end

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

@@ -1,7 +1,7 @@
 module Cats
   module Core
     class LostCommodity < ApplicationRecord
-      belongs_to :receipt
+      belongs_to :dispatch
 
       validates :quantity, presence: true
       validates :commodity_status, presence: true, inclusion: { in: Commodity::COMMODITY_STATUSES }

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

@@ -10,7 +10,7 @@ module Cats
 
       belongs_to :dispatch
       belongs_to :prepared_by, class_name: 'Cats::Core::User'
-      has_many :receipt_transactions, foreign_key: :source_id
+      has_many :receipt_transactions
 
       validates :quantity, :commodity_status, :status, presence: true
       validates :quantity, numericality: { greater_than: 0 }
@@ -33,7 +33,7 @@ module Cats
       def validate_total_quantity
         return unless dispatch && quantity
 
-        received = dispatch.receipts.sum(:quantity)
+        received = dispatch.receipts.sum(:quantity) + dispatch.lost_commodities.sum(:quantity)
         diff = dispatch.quantity - received
         diff += quantity_was if quantity_was
 

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

@@ -1,11 +1,29 @@
 module Cats
   module Core
     class ReceiptTransaction < Transaction
-      belongs_to :source, class_name: 'Cats::Core::Receipt'
+      belongs_to :receipt
       belongs_to :destination, class_name: 'Cats::Core::Stack'
 
       delegate(:code, to: :destination, prefix: true)
 
+      def validate_quantity
+        return unless quantity.present? && destination.present? && receipt.present?
+
+        authorized = receipt.dispatch.dispatch_plan_item.hub_authorizations.where(
+          store: destination.store
+        ).sum(:quantity)
+        received = self.class.joins(:destination).where(
+          destination: { store_id: destination.store_id }
+        ).sum(:quantity)
+
+        received -= quantity_was if quantity_was
+
+        # Get quantity in hub authorization for source
+        available = authorized - received
+
+        errors.add(:quantity, "exceeds authorized quantity (Max = #{available}).") if quantity > available
+      end
+
       def commit
         ReceiptTransaction.transaction do
           destination.quantity += quantity

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

@@ -71,6 +71,7 @@ module Cats
         return unless store.present? && length.present? && width.present? && start_x.present? && start_y.present?
 
         stacks = store.stacks.where(stack_status: [RESERVED, ALLOCATED]).where.not(id: id)
+
         stacks.each do |s|
           errors.add(:base, message: "#{code} overlaps with #{s.code}") if overlaps?(self, s)
         end

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

@@ -3,6 +3,17 @@ module Cats
     class StackTransaction < Transaction
       belongs_to :source, class_name: 'Cats::Core::Stack'
       belongs_to :destination, class_name: 'Cats::Core::Stack'
+
+      def validate_quantity
+        return unless quantity.present? && source.present?
+
+        dispatched = StackTransaction.where(source: source, status: DRAFT).sum(:quantity)
+
+        available = source.quantity - dispatched
+        available += quantity_was if quantity_was
+
+        errors.add(:quantity, "total is higher than source quantity (Max = #{available}).") if quantity > available
+      end
     end
   end
 end

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

@@ -15,14 +15,19 @@ module Cats
       validate :validate_quantity, unless: :skip_quantity_validation
 
       def validate_quantity
-        return unless quantity.present? && source.present?
+        return unless quantity.present? && source.present? && dispatch.present?
 
-        dispatched = self.class.where(source: source, status: DRAFT).sum(:quantity)
+        dispatched = self.class.joins(:source, :dispatch).where(
+          source: { store_id: source.store_id },
+          dispatch: { dispatch_plan_item_id: dispatch.dispatch_plan_item_id }
+        ).sum(:quantity)
+        dispatched -= quantity_was if quantity_was
 
-        available = source.quantity - dispatched
-        available += quantity_was if quantity_was
+        # Get quantity in hub authorization for source
+        authorized = dispatch.dispatch_plan_item.hub_authorizations.where(store_id: source.store_id).sum(:quantity)
+        available = authorized - dispatched
 
-        errors.add(:quantity, "total is higher than source quantity (Max = #{available}).") if quantity > available
+        errors.add(:quantity, "exceeds authorized quantity (Max = #{available}).") if quantity > available
       end
 
       def commit
@@ -33,12 +38,12 @@ module Cats
         # Quantity validation should be skipped if we are commiting transactions.
         (
           instance_of?(Cats::Core::DispatchTransaction) &&
-          destination &&
-          destination.dispatch_status == Cats::Core::Dispatch::STARTED
+          dispatch &&
+          status == COMMITTED
         ) || (
           instance_of?(Cats::Core::ReceiptTransaction) &&
-          source &&
-          source.status == Cats::Core::Receipt::STACKING
+          receipt &&
+          receipt.status == Cats::Core::Receipt::STACKING
         )
       end
 

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

@@ -1,7 +1,11 @@
 module Cats
   module Core
     class CommodityCategorySerializer < ActiveModel::Serializer
-      attributes :id, :code, :name, :description, :parent_id
+      attributes :id, :code, :name, :description, :parent_id, :leaf
+
+      def leaf
+        !object.has_children?
+      end
     end
   end
 end

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

@@ -2,7 +2,8 @@ module Cats
   module Core
     class DispatchPlanItemSerializer < ActiveModel::Serializer
       attributes :id, :dispatch_plan_id, :plan_reference_no, :source_id, :source_name, :destination_id,
-                 :destination_name, :quantity, :source_location_type, :destination_location_type, :commodity_status
+                 :destination_name, :quantity, :source_location_type, :destination_location_type, :commodity_status,
+                 :status
     end
   end
 end

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

@@ -1,7 +1,7 @@
 module Cats
   module Core
     class DispatchTransactionSerializer < ActiveModel::Serializer
-      attributes :id, :source_id, :source_code, :destination_id, :destination_reference_no, :quantity,
+      attributes :id, :source_id, :source_code, :dispatch_id, :dispatch_reference_no, :quantity,
                  :transaction_date, :status
     end
   end

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

@@ -1,7 +1,7 @@
 module Cats
   module Core
     class LostCommoditySerializer < ActiveModel::Serializer
-      attributes :id, :receipt_id, :quantity, :commodity_status, :remark
+      attributes :id, :dispatch_id, :quantity, :commodity_status, :remark
     end
   end
 end

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

@@ -0,0 +1,8 @@
+module Cats
+  module Core
+    class MonthlyPlanSerializer < ActiveModel::Serializer
+      attributes :id, :reference_no, :status, :plan_id, :plan_reference_no, :region_id, :region_name, :month,
+                 :no_of_days
+    end
+  end
+end

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

@@ -1,11 +1,11 @@
 module Cats
   module Core
     class ReceiptTransactionSerializer < ActiveModel::Serializer
-      attributes :id, :source_id, :dispatch_reference, :destination_id, :destination_code, :quantity, :transaction_date,
-                 :status
+      attributes :id, :receipt_id, :dispatch_reference, :destination_id, :destination_code, :quantity,
+                 :transaction_date, :status
 
       def dispatch_reference
-        object.source.dispatch.reference_no
+        object.receipt.dispatch.reference_no
       end
     end
   end

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

@@ -0,0 +1,8 @@
+module Cats
+  module Core
+    class StackSerializer < ActiveModel::Serializer
+      attributes :id, :code, :length, :width, :height, :start_x, :start_y, :commodity_id, :store_id, :commodity_status,
+                 :stack_status, :quantity, :commodity_batch_no
+    end
+  end
+end

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

@@ -4,7 +4,27 @@ module Cats
       def approve(plan)
         plan.approve
 
-        plan.dispatchable.allocate if plan.dispatchable_type == RhnRequest.name
+        if plan.upstream
+          # Create source hub authorizations for each item and
+          # put them in a `Source Authorized` state
+          store = Store.find_by(code: 'SUP-STORE')
+          keeper = User.find_by(first_name: 'SUP-Storekeeper')
+          authorizations = []
+          plan.dispatch_plan_items.each do |item|
+            authorizations << {
+              dispatch_plan_item_id: item.id,
+              store_id: store.id,
+              quantity: item.quantity,
+              authorization_type: HubAuthorization::SOURCE,
+              authorized_by_id: keeper.id,
+              created_at: Date.today,
+              updated_at: Date.today
+            }
+          end
+          HubAuthorization.insert_all(authorizations)
+          plan.dispatch_plan_items.update_all(status: DispatchPlanItem::SOURCE_AUTHORIZED)
+          plan.dispatchable.allocate
+        end
         # send_notification(plan)
         plan
       end

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

@@ -1,47 +1,6 @@
 module Cats
   module Core
     class DispatchService
-      def create_receipt_authorization(reference_no, plan_item, quantity, remark, user)
-        raise(StandardError, 'Dispatch plan is not an upstream plan.') unless plan_item.dispatch_plan.upstream?
-
-        transporter = Cats::Core::Transporter.find_by(code: 'SUP-TRANS')
-        raise(StandardError, 'Supplier transporter does not exist.') unless transporter
-
-        store = Cats::Core::Store.find_by(code: 'SUP-STORE')
-        raise(StandardError, 'Supplier store does not exist.') unless store
-
-        commodity = plan_item.dispatch_plan.commodity
-        stack = store.stacks.find_by(commodity: commodity)
-
-        raise(StandardError, 'Commodity not found in supplier store.') unless stack
-
-        dispatch = nil
-        ApplicationRecord.transaction do
-          dispatch = Cats::Core::Dispatch.create!(
-            reference_no: reference_no,
-            dispatch_plan_item: plan_item,
-            transporter: transporter,
-            plate_no: 'Supplier plate no',
-            driver_name: 'Supplier driver',
-            driver_phone: 'Supplier driver phone',
-            quantity: quantity,
-            remark: remark,
-            prepared_by: user,
-            dispatch_status: Cats::Core::Dispatch::DRAFT
-          )
-
-          # Create a dispatch transaction
-          Cats::Core::DispatchTransaction.create!(
-            source: stack,
-            destination: dispatch,
-            transaction_date: Date.today,
-            quantity: quantity,
-            status: Cats::Core::Transaction::DRAFT
-          )
-        end
-        dispatch
-      end
-
       def search(user, status)
         details = user.details
 
@@ -49,44 +8,20 @@ module Cats
           raise(StandardError, 'User does not have associated location.')
         end
 
-        if details['stores']
-          warehouse = Cats::Core::Store.find(details['stores'][0]).warehouse
-          hub = warehouse.parent
-
-          dispatches = Cats::Core::Dispatch.joins(:dispatch_plan_item)
-                                           .where(
-                                             dispatch_plan_item: { destination: hub },
-                                             dispatch_status: status
-                                           ).or(
-                                             Cats::Core::Dispatch.joins(:dispatch_plan_item)
-                                                                 .where(
-                                                                   dispatch_plan_item: { destination: warehouse },
-                                                                   dispatch_status: status
-                                                                 )
-                                           )
-        elsif details['warehouse']
-          warehouse = Cats::Core::Location.find(details['warehouse'])
-          hub = warehouse.parent
-          dispatches = Cats::Core::Dispatch.joins(:dispatch_plan_item)
-                                           .where(
-                                             dispatch_plan_item: { destination: hub },
-                                             dispatch_status: status
-                                           ).or(
-                                             Cats::Core::Dispatch.joins(:dispatch_plan_item)
-                                                                 .where(
-                                                                   dispatch_plan_item: { destination: warehouse },
-                                                                   dispatch_status: status
-                                                                 )
-                                           )
-        elsif details['hub']
-          hub = Cats::Core::Location.find(details['hub'])
-          dispatches = Cats::Core::Dispatch.joins(:dispatch_plan_item)
-                                           .where(
-                                             dispatch_plan_item: { destination: hub },
-                                             dispatch_status: status
-                                           )
-        end
-        dispatches
+        # Get user's hub
+        hub = if details['stores']
+                Cats::Core::Store.find(details['stores'][0]).warehouse.parent
+              elsif details['warehouse']
+                Cats::Core::Location.find(details['warehouse']).parent
+              else
+                Cats::Core::Location.find(details['hub'])
+              end
+
+        Cats::Core::Dispatch.joins(:dispatch_plan_item)
+                            .where(
+                              dispatch_plan_item: { destination: hub },
+                              dispatch_status: status
+                            )
       end
 
       def start(dispatch)
@@ -101,9 +36,11 @@ module Cats
 
         users = Cats::Core::User.joins(:roles).where(cats_core_roles: { name: notification_rule.roles })
         location_id = dispatch.dispatch_plan_item.destination_id
+        hub = Cats::Core::Location.find(location_id)
         recipients = users.map do |user|
           details = user.details
-          if (details.key?('warehouse') && details['warehouse'] == location_id) ||
+
+          if (details.key?('warehouse') && hub.child_ids.include?(details['warehouse'])) ||
              (details.key?('hub') && details['hub'] == location_id)
             user
           end

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

@@ -0,0 +1,86 @@
+module Cats
+  module Core
+    class MonthlyPlanService
+      def generate_monthly_needs(plan_id)
+        plan = Cats::Core::MonthlyPlan.find(plan_id)
+        raise(StandardError, 'Plan has no rations.') if plan.monthly_rations.count.zero?
+
+        raise(StandardError, 'Plan has no plan items.') if plan.monthly_plan_items.count.zero?
+
+        plan.monthly_plan_item_details.delete_all if plan.monthly_plan_item_details.count.positive?
+
+        details = []
+        plan.monthly_plan_items.each do |plan_item|
+          plan.monthly_rations.each do |ration|
+            details << {
+              monthly_plan_item_id: plan_item.id,
+              monthly_ration_id: ration.id,
+              amount: (plan.no_of_days / ration.no_of_days * ration.amount) * plan_item.beneficiaries,
+              created_at: Date.today,
+              updated_at: Date.today
+            }
+          end
+        end
+
+        Cats::Core::MonthlyPlanItemDetail.insert_all!(details)
+        plan
+      end
+
+      def generate_monthly_plan(params)
+        region = Cats::Core::Location.find(params[:region_id])
+        plan = Cats::Core::Plan.includes(plan_items: :plan_item_details).find(params[:plan_id])
+        rations = Cats::Core::RationItem.where(ration_id: plan.ration_id)
+        monthly_plan = Cats::Core::MonthlyPlan.create!(
+          plan_id: plan.id,
+          reference_no: params[:reference_no],
+          region_id: params[:region_id],
+          status: Cats::Core::Plan::DRAFT,
+          month: params[:month],
+          no_of_days: params[:no_of_days]
+        )
+        ration_items = rations.map do |ration|
+          {
+            commodity_category_id: ration.commodity_category_id,
+            amount: ration.amount,
+            unit_of_measure_id: ration.unit_of_measure_id,
+            no_of_days: ration.no_of_days,
+            monthly_plan_id: monthly_plan.id,
+            created_at: Date.today,
+            updated_at: Date.today
+          }
+        end
+        Cats::Core::MonthlyRation.insert_all!(ration_items)
+
+        plan_items = plan.plan_items.where(woreda_id: region.descendant_ids).map do |plan_item|
+          {
+            monthly_plan_id: monthly_plan.id,
+            beneficiaries: plan_item.beneficiaries,
+            plan_item_id: plan_item.id,
+            created_at: Date.today,
+            updated_at: Date.today
+          }
+        end
+        Cats::Core::MonthlyPlanItem.insert_all!(plan_items)
+        monthly_plan
+      end
+
+      def remove_items(plan_id, ids)
+        raise(StandardError, 'No plan items specified.') if ids.count.zero?
+
+        begin
+          plan = Cats::Core::MonthlyPlan.find(plan_id)
+        rescue ActiveRecord::RecordNotFound
+          raise(StandardError, 'Monthly plan not found.') unless plan
+        end
+
+        plans = Cats::Core::MonthlyPlan.includes(:monthly_plan_items).where(monthly_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 monthly plan.') unless plan_id == plans[0].id
+
+        Cats::Core::MonthlyPlanItem.delete_by(id: ids)
+        plan
+      end
+    end
+  end
+end

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

@@ -16,11 +16,33 @@ module Cats
           raise(StandardError, 'Receipt should be in stacking state.')
         end
 
+        receipt.receipt_transactions.each(&:commit)
         receipt.status = Cats::Core::Receipt::STACKED
         receipt.save!
-        receipt.receipt_transactions.each(&:commit)
         receipt
       end
+
+      def init(params)
+        receipt = Cats::Core::Receipt.find_by(
+          dispatch_id: params[:dispatch_id],
+          commodity_status: params[:commodity_status]
+        )
+
+        if receipt
+          # We can assume that the plan item is destination authorized.
+          # Therefore no need for checking destination authorization.
+          receipt.quantity += params[:quantity]
+          return receipt
+        end
+
+        # Check if plan item is destination authorized
+        dispatch = Dispatch.find(params[:dispatch_id])
+        status = dispatch.dispatch_plan_item.status
+        statuses = [DispatchPlanItem::DESTINATION_AUTHORIZED, DispatchPlanItem::AUTHORIZED]
+        raise(StandardError, 'Plan item is not destination authorized.') unless statuses.include?(status)
+
+        Receipt.new(params)
+      end
     end
   end
 end

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

@@ -0,0 +1,59 @@
+module Cats
+  module Core
+    class StackService
+      def commodity_for_location(user)
+        details = user.details
+
+        key_available = details.keys.any? { |key| %w[stores warehouse hub].include?(key) }
+        raise(StandardError, 'User does not have associated location.') unless key_available
+
+        if details['hub']
+          hub = Cats::Core::Location.find(details['hub'])
+          allocation_items =
+            Cats::Core::AllocationItem
+            .joins(allocation: :commodity)
+            .where(destination: hub, allocation: { allocation_status: Cats::Core::Allocation::APPROVED })
+        else
+          if details['stores']
+            warehouse = Cats::Core::Store.find(details['stores'][0]).warehouse
+            hub = warehouse.parent
+          elsif details['warehouse']
+            warehouse = Cats::Core::Location.find(details['warehouse'])
+            hub = warehouse.parent
+          end
+          allocation_items =
+            Cats::Core::AllocationItem
+            .joins(allocation: :commodity)
+            .where(destination: hub, allocation: { allocation_status: Cats::Core::Allocation::APPROVED })
+            .or(
+              Cats::Core::AllocationItem
+                .joins(allocation: :commodity)
+                .where(destination: warehouse, allocation: { allocation_status: Cats::Core::Allocation::APPROVED })
+            )
+        end
+
+        allocation_items.map do |item|
+          {
+            reference_no: item.allocation.reference_no,
+            source: item.allocation.source.name,
+            destination: item.destination.name,
+            quantity: item.quantity,
+            batch_no: item.allocation.commodity.batch_no,
+            commodity_id: item.allocation.commodity_id,
+            commodity_name: item.allocation.commodity.name,
+            unit: item.allocation.commodity.unit_of_measure.abbreviation
+          }
+        end
+      end
+
+      def receipt_stacks(receipt)
+        location = receipt.dispatch.dispatch_plan_item.destination
+        warehouses = location.children
+        stores = Cats::Core::Store.where(warehouse: warehouses)
+
+        commodity = receipt.dispatch.dispatch_plan_item.dispatch_plan.commodity
+        Cats::Core::Stack.where(commodity: commodity, store: stores)
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -65,8 +65,16 @@ Cats::Core::Engine.routes.draw do
       get 'children'
     end
   end
+  post '/commodities/filter', controller: :commodities, action: :filter
+  resources :commodities, except: %i[destroy] do
+    member do
+      post 'approve'
+    end
+  end
   resources :currencies, except: %i[destroy]
   resources :unit_of_measures, except: %i[destroy]
+
+  post '/transporters/filter', controller: :transporters, action: :filter
   resources :transporters, except: %i[destroy]
 
   post '/routes/filter', controller: :routes, action: :filter
@@ -82,32 +90,52 @@ Cats::Core::Engine.routes.draw do
 
   resources :dispatch_plan_items, except: %i[index destroy]
 
+  post '/dispatch_plan_items/filter', controller: :dispatch_plan_items, action: :filter
   get '/dispatch_plan_items/:id/dispatches', controller: :dispatches, action: :index, as: :dispatches_plan_item
-  post '/dispatch_plan_items/:id/receipt_authorizaton',
-       controller: :dispatches,
-       action: :create_receipt_authorization,
-       as: :receipt_authorization_plan_item
 
   get '/dispatches/search', controller: :dispatches, action: :search, as: :search_dispatches
   resources :dispatches, except: %i[index destroy] do
     member do
       get 'transactions', controller: :dispatch_transactions, action: :index
       get 'receipts', controller: :receipts, action: :index
+      get 'lost', controller: :lost_commodities, action: :index
       get 'commodity'
       post 'approve'
       post 'start'
       post 'confirm'
     end
   end
+
+  post(
+    'dispatch_transactions/allocation',
+    controller: :dispatch_transactions,
+    action: :create_allocation,
+    as: :allocation_transaction
+  )
   resources :dispatch_transactions, except: %i[index new edit destroy]
   resources :receipts, except: %i[index new edit destroy] do
     member do
       get 'transactions', controller: :receipt_transactions, action: :index
-      get 'lost', controller: :lost_commodities, action: :index
       post 'start_stacking'
       post 'finish_stacking'
     end
   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
+    member do
+      post 'remove_items'
+      post 'generate_monthly_needs'
+      post 'approve'
+    end
+  end
+
+  get '/stores/:id/stacks', controller: :stacks, action: :index, as: :stacks_store
+  post '/stores/:id/stacks', controller: :stacks, action: :filter
+  get '/stacks/commodity_for_location', controller: :stacks, action: :commodity_for_location, as: :commodity_for_location
+  get '/receipts/:id/stacks', controller: :stacks, action: :receipt_stacks, as: :receipt_stacks
+  resources :stacks, only: %i[show index create update]
 end

data/db/migrate/20210718045516_create_cats_core_dispatches.rb

@@ -13,7 +13,7 @@ class CreateCatsCoreDispatches < ActiveRecord::Migration[6.1]
       t.string :plate_no, null: false
       t.string :driver_name, null: false
       t.string :driver_phone, null: false
-      t.float :quantity, null: false
+      t.float :quantity, null: false, default: 0
       t.string :commodity_status, null: false, default: 'Good'
       t.string :remark
       t.references :prepared_by,

data/db/migrate/20210718202957_create_cats_core_dispatch_transactions.rb

@@ -5,7 +5,7 @@ class CreateCatsCoreDispatchTransactions < ActiveRecord::Migration[6.1]
                    null: false,
                    index: { name: 'stack_on_dt_indx' },
                    foreign_key: { to_table: :cats_core_stacks }
-      t.references :destination,
+      t.references :dispatch,
                    null: false,
                    index: { name: 'dispatch_on_dt_indx' },
                    foreign_key: { to_table: :cats_core_dispatches }

data/db/migrate/{20220221041505_create_cats_core_lost_commodities.rb → 20210728041505_create_cats_core_lost_commodities.rb}

@@ -1,10 +1,10 @@
 class CreateCatsCoreLostCommodities < ActiveRecord::Migration[7.0]
   def change
     create_table :cats_core_lost_commodities do |t|
-      t.references :receipt,
+      t.references :dispatch,
                    null: false,
-                   index: { name: 'lc_on_receipt_indx' },
-                   foreign_key: { to_table: :cats_core_receipts }
+                   index: { name: 'lc_on_dispatch_indx' },
+                   foreign_key: { to_table: :cats_core_dispatches }
       t.float :quantity, null: false
       t.string :commodity_status, null: false
       t.string :remark

data/db/migrate/20210814160628_create_cats_core_receipt_transactions.rb

@@ -1,7 +1,7 @@
 class CreateCatsCoreReceiptTransactions < ActiveRecord::Migration[6.1]
   def change
     create_table :cats_core_receipt_transactions do |t|
-      t.references :source,
+      t.references :receipt,
                    null: false,
                    index: { name: 'receipt_on_rt_indx' },
                    foreign_key: { to_table: :cats_core_receipts }

data/lib/cats/core/version.rb

@@ -1,5 +1,5 @@
 module Cats
   module Core
-    VERSION = '1.3.36'.freeze
+    VERSION = '1.3.39'.freeze
   end
 end

data/spec/factories/cats/core/dispatch_transactions.rb

@@ -1,7 +1,15 @@
 FactoryBot.define do
   factory :dispatch_transaction, class: 'Cats::Core::DispatchTransaction' do
-    source factory: :stack
-    destination factory: :dispatch
+    transient do
+      stack { create(:stack) }
+    end
+    source { stack }
+    dispatch do
+      plan_item = create(:dispatch_plan_item, quantity: 100)
+      plan_item.dispatch_plan.approve
+      create(:hub_authorization, dispatch_plan_item: plan_item, quantity: 100, store: stack.store)
+      create(:dispatch, dispatch_plan_item: plan_item, transaction?: false)
+    end
     transaction_date { Date.today }
     quantity { 10 }
     status { Cats::Core::Transaction::DRAFT }

data/spec/factories/cats/core/dispatches.rb

@@ -1,18 +1,26 @@
 FactoryBot.define do
   factory :dispatch, class: 'Cats::Core::Dispatch' do
+    transient do
+      stack { create(:stack, quantity: 100) }
+      transaction? { true }
+    end
     reference_no { FFaker::Name.name }
     dispatch_plan_item do
       plan_item = create(:dispatch_plan_item, quantity: 100)
       plan_item.dispatch_plan.approve
+      create(:hub_authorization, dispatch_plan_item: plan_item, quantity: 100, store: stack.store)
       plan_item
     end
     transporter
     plate_no { FFaker::Name.name }
     driver_name { FFaker::Name.name }
     driver_phone { FFaker::Name.name }
-    quantity { 50 }
     remark { FFaker::Name.name }
     prepared_by factory: :user
     dispatch_status { Cats::Core::Dispatch::DRAFT }
+
+    after :create do |dispatch, options|
+      create(:dispatch_transaction, dispatch: dispatch, source: options.stack, quantity: 100) if options.transaction?
+    end
   end
 end

data/spec/factories/cats/core/lost_commodities.rb

@@ -1,6 +1,6 @@
 FactoryBot.define do
   factory :lost_commodity, class: 'Cats::Core::LostCommodity' do
-    receipt
+    dispatch
     quantity { 100 }
     commodity_status { Cats::Core::Commodity::DAMAGED }
     remark { FFaker::Name.name }

data/spec/factories/cats/core/receipt_transactions.rb

@@ -1,9 +1,29 @@
 FactoryBot.define do
   factory :receipt_transaction, class: 'Cats::Core::ReceiptTransaction' do
-    source factory: :receipt
-    destination factory: :stack
+    transient do
+      dispatch { create(:dispatch) }
+    end
+    transient do
+      stack { create(:stack) }
+    end
+
+    destination { stack }
+    receipt do
+      dispatch.approve
+      dispatch.start
+      receipt = create(:receipt, dispatch: dispatch)
+      dispatch.confirm
+      create(
+        :hub_authorization,
+        authorization_type: Cats::Core::HubAuthorization::DESTINATION,
+        dispatch_plan_item: dispatch.dispatch_plan_item,
+        store: stack.store,
+        quantity: 100
+      )
+      receipt
+    end
     transaction_date { Date.today }
-    quantity { 10 }
+    quantity { 100 }
     status { Cats::Core::Transaction::DRAFT }
   end
 end

data/spec/factories/cats/core/receipts.rb

@@ -2,12 +2,11 @@ FactoryBot.define do
   factory :receipt, class: 'Cats::Core::Receipt' do
     dispatch do
       dispatch = create(:dispatch)
-      create(:dispatch_transaction, destination: dispatch, quantity: 50)
       dispatch.approve
       dispatch.start
       dispatch
     end
-    quantity { 50 }
+    quantity { 100 }
     commodity_status { Cats::Core::Commodity::GOOD }
     status { Cats::Core::Receipt::DRAFT }
     remark { FFaker::Name.name }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cats_core
 version: !ruby/object:Gem::Version
-  version: 1.3.36
+  version: 1.3.39
 platform: ruby
 authors:
 - Henock L.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-21 00:00:00.000000000 Z
+date: 2022-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -232,6 +232,7 @@ files:
 - Rakefile
 - app/controllers/cats/core/access_controller.rb
 - app/controllers/cats/core/application_controller.rb
+- app/controllers/cats/core/commodities_controller.rb
 - app/controllers/cats/core/commodity_categories_controller.rb
 - app/controllers/cats/core/currencies_controller.rb
 - app/controllers/cats/core/dispatch_plan_items_controller.rb
@@ -241,12 +242,14 @@ files:
 - app/controllers/cats/core/locations_controller.rb
 - app/controllers/cats/core/lost_commodities_controller.rb
 - app/controllers/cats/core/menus_controller.rb
+- app/controllers/cats/core/monthly_plans_controller.rb
 - app/controllers/cats/core/notifications_controller.rb
 - app/controllers/cats/core/receipt_transactions_controller.rb
 - app/controllers/cats/core/receipts_controller.rb
 - app/controllers/cats/core/roles_controller.rb
 - app/controllers/cats/core/routes_controller.rb
 - app/controllers/cats/core/spaces_controller.rb
+- app/controllers/cats/core/stacks_controller.rb
 - app/controllers/cats/core/transporters_controller.rb
 - app/controllers/cats/core/unit_of_measures_controller.rb
 - app/controllers/cats/core/users_controller.rb
@@ -323,20 +326,24 @@ files:
 - app/serializers/cats/core/dispatch_transaction_serializer.rb
 - app/serializers/cats/core/location_serializer.rb
 - app/serializers/cats/core/lost_commodity_serializer.rb
+- app/serializers/cats/core/monthly_plan_serializer.rb
 - app/serializers/cats/core/receipt_serializer.rb
 - app/serializers/cats/core/receipt_transaction_serializer.rb
 - app/serializers/cats/core/role_menu_serializer.rb
 - app/serializers/cats/core/role_serializer.rb
 - app/serializers/cats/core/route_serializer.rb
+- app/serializers/cats/core/stack_serializer.rb
 - app/serializers/cats/core/transporter_serializer.rb
 - app/serializers/cats/core/unit_of_measure_serializer.rb
 - app/serializers/cats/core/user_serializer.rb
 - app/services/cats/core/dispatch_plan_service.rb
 - app/services/cats/core/dispatch_service.rb
 - app/services/cats/core/menu_service.rb
+- app/services/cats/core/monthly_plan_service.rb
 - app/services/cats/core/notification_service.rb
 - app/services/cats/core/receipt_service.rb
 - app/services/cats/core/space_service.rb
+- app/services/cats/core/stack_service.rb
 - app/services/cats/core/token_auth_service.rb
 - config/routes.rb
 - db/migrate/20210715114238_create_cats_core_application_modules.rb
@@ -376,6 +383,7 @@ files:
 - db/migrate/20210719133710_create_cats_core_stacking_rules.rb
 - db/migrate/20210724074657_create_cats_core_notifications.rb
 - db/migrate/20210727074646_create_cats_core_receipts.rb
+- db/migrate/20210728041505_create_cats_core_lost_commodities.rb
 - db/migrate/20210814160628_create_cats_core_receipt_transactions.rb
 - db/migrate/20210814175406_create_cats_core_stack_transactions.rb
 - db/migrate/20211002050739_create_cats_core_notification_rules.rb
@@ -396,7 +404,6 @@ files:
 - db/migrate/20220107125025_create_cats_core_monthly_plan_items.rb
 - db/migrate/20220107132433_create_cats_core_monthly_plan_item_details.rb
 - db/migrate/20220209083928_create_cats_core_hub_authorizations.rb
-- db/migrate/20220221041505_create_cats_core_lost_commodities.rb
 - lib/cats/core.rb
 - lib/cats/core/engine.rb
 - lib/cats/core/version.rb