cats_core 1.4.19 → 1.4.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f2cc951417c8b5c1586ad4deb540c51e54177eac53c54a689f31c35bfbfbb67
-  data.tar.gz: f25cbb325f2eb8b8c9081ec0660b3c3028fe45ee0b7f003c40e96c91cdfebd15
+  metadata.gz: a3a896be87ee316cd08b40a298effac694bfb59e1207699c50675b4242e0f630
+  data.tar.gz: 3b6d584ce3eacbf6a0f3ffda03c399d84db2c5bf3931666107cf9d7fd014e3ca
 SHA512:
-  metadata.gz: 610169114a8fd878d1fd47b771f55a5bfef3e79c3d660b8148642a8fd9def6e018f4cea2b6cda50ee381970f2bee3e9e98ff5d5f0a3f66436d340b8334e4bf75
-  data.tar.gz: b0d90834aba82fd86dfb53bd6b51a875ff1131c4a3096813d6132efc860915e89ea4dd63c7272518158af8c0d21b355557e055b86d08938e82f063ce743a8f0a
+  metadata.gz: 234470131214a8e68da2123957a811c55c41c38079c34ec9dde9b9313c0d85c7b88607da5b0a3d7a2dd98f1c2f39942f5790a858d21eb76595a9f0572578d3a5
+  data.tar.gz: 4f3e4040eff76a430bbcaf24ec3bae51dc54905831f744f23802905c4d6df80cc440184de47c9398be98051be81519010cf4ca9e3818817a3b1fc67b9cd3dda8

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

@@ -0,0 +1,27 @@
+module Cats
+  module Core
+    class DispatchAuthorizationsController < ApplicationController
+      include Common
+
+      def index
+        super do
+          DispatchAuthorization.where(dispatch_id: params[:id])
+        end
+      end
+
+      def confirm
+        authorization = DispatchAuthorization.find(params[:id])
+        authorization.confirm
+        render json: { success: true, data: serialize(authorization) }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:dispatch_id, :store_id, :quantity, :status, :authorized_by_id)
+      end
+    end
+  end
+end

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

@@ -17,8 +17,8 @@ module Cats
       private
 
       def model_params
-        params.require(:payload).permit(:dispatch_plan_id, :source_id, :destination_id, :quantity, :commodity_status,
-                                        :status, :commodity_id)
+        params.require(:payload).permit(:reference_no, :dispatch_plan_id, :source_id, :destination_id, :quantity,
+                                        :commodity_status, :status, :commodity_id)
       end
     end
   end

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

@@ -5,7 +5,7 @@ module Cats
 
       def index
         super do
-          DispatchTransaction.where(dispatch_id: params[:id])
+          DispatchTransaction.where(dispatch_authorization_id: params[:id])
         end
       end
 
@@ -14,8 +14,8 @@ module Cats
       # 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.commodity
+        authorization = DispatchAuthorization.find(model_params[:dispatch_authorization_id])
+        commodity = authorization.dispatch.dispatch_plan_item.commodity
         transaction = DispatchTransaction.new(model_params)
 
         # Fetch supplier stack by commodity
@@ -32,7 +32,7 @@ module Cats
       private
 
       def model_params
-        params.require(:payload).permit(:source_id, :dispatch_id, :transaction_date, :quantity)
+        params.require(:payload).permit(:source_id, :dispatch_authorization_id, :transaction_date, :quantity)
       end
     end
   end

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

@@ -60,8 +60,8 @@ module Cats
       end
 
       def model_params
-        params.require(:payload).permit(:reference_no, :dispatch_plan_item_id, :transporter_id, :plate_no,
-                                        :driver_name, :driver_phone, :quantity, :remark)
+        params.require(:payload).permit(:reference_no, :dispatch_plan_item_id, :transporter_id, :plate_no, :unit_id,
+                                        :driver_name, :driver_phone, :remark)
       end
     end
   end

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

@@ -0,0 +1,28 @@
+module Cats
+  module Core
+    class ReceiptAuthorizationsController < ApplicationController
+      include Common
+
+      def index
+        super do
+          ReceiptAuthorization.where(dispatch_id: params[:id])
+        end
+      end
+
+      def confirm
+        authorization = ReceiptAuthorization.find(params[:id])
+        authorization.confirm
+        render json: { success: true, data: serialize(authorization) }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:dispatch_id, :store_id, :quantity, :lost_quantity, :remark, :status,
+                                        :authorized_by_id)
+      end
+    end
+  end
+end

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

@@ -5,32 +5,14 @@ module Cats
 
       def index
         super do
-          ReceiptTransaction.where(receipt_id: params[:id])
-        end
-      end
-
-      def create
-        super do
-          p = model_params
-
-          # Look for a transaction with the same destination as incoming
-          transaction = ReceiptTransaction.find_by(
-            receipt_id: p[:receipt_id],
-            destination_id: p[:destination_id]
-          )
-          if transaction
-            transaction.quantity += p[:quantity]
-          else
-            transaction = ReceiptTransaction.new(p)
-          end
-          transaction
+          ReceiptTransaction.joins(receipt_authorization: :dispatch).where(receipt_authorization_id: params[:id])
         end
       end
 
       private
 
       def model_params
-        params.require(:payload).permit(:receipt_id, :destination_id, :transaction_date, :quantity)
+        params.require(:payload).permit(:receipt_authorization_id, :destination_id, :transaction_date, :quantity)
       end
     end
   end

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

@@ -0,0 +1,65 @@
+module Cats
+  module Core
+    class Authorization < ApplicationRecord
+      self.abstract_class = true
+      after_initialize :set_status
+
+      # Authorization statuses
+      AUTHORIZED = 'Authorized'.freeze
+      CONFIRMED = 'Confirmed'.freeze
+      STATUSES = [AUTHORIZED, CONFIRMED].freeze
+
+      belongs_to :dispatch
+      belongs_to :store
+      belongs_to :authorized_by, class_name: 'Cats::Core::User'
+
+      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validates :status, presence: true, inclusion: { in: STATUSES }
+      validate :validate_dispatch_status, if: -> { status == AUTHORIZED }
+
+      delegate(:full_name, to: :authorized_by, prefix: :authorizer)
+      delegate(:name, to: :store, prefix: true)
+      delegate(:reference_no, to: :dispatch, prefix: true)
+
+      def validate_dispatch_status
+        return unless dispatch
+
+        if instance_of?(DispatchAuthorization)
+          errors.add(:dispatch, 'is not in draft state.') unless dispatch.dispatch_status == Dispatch::DRAFT
+        else
+          return if dispatch.dispatch_status == Cats::Core::Dispatch::STARTED
+
+          errors.add(:dispatch, 'should be in "Started" state.')
+        end
+      end
+
+      # A convenience method to return dispatch or receipt transactions based on the
+      # authorization type.
+      def transactions
+        return dispatch_transactions if instance_of?(DispatchAuthorization)
+
+        return receipt_transactions if instance_of?(ReceiptAuthorization)
+      end
+
+      def confirm
+        # Check if all transactions are committed first.
+        if instance_of?(DispatchAuthorization)
+          raise(StandardError, 'Authorization does not have transactions.') if transactions.blank?
+
+          count = transactions.where(status: Transaction::DRAFT).count
+          raise(StandardError, 'There are uncommitted transactions.') if count.positive?
+        end
+        self.status = CONFIRMED
+        save!
+      end
+
+      private
+
+      def set_status
+        return unless new_record?
+
+        self.status = AUTHORIZED
+      end
+    end
+  end
+end

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

@@ -13,33 +13,25 @@ module Cats
       belongs_to :prepared_by, class_name: 'Cats::Core::User'
       belongs_to :transporter
       belongs_to :dispatch_plan_item
-      has_many :receipts
-      has_many :dispatch_transactions
-      has_many :lost_commodities
+      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
+
+      has_many :dispatch_authorizations
+      has_many :receipt_authorizations
+      has_many :dispatch_transactions, through: :dispatch_authorizations
+      has_many :receipt_transactions, through: :receipt_authorizations
 
       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_or_equal_to: 0 }
       validates :commodity_status, inclusion: { in: Cats::Core::Commodity::COMMODITY_STATUSES }
-      validate :validate_quantity, :validate_dispatch_plan_status
+      validate :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
-
-        return unless quantity_changed?
-
-        dispatched = dispatch_plan_item.dispatches.sum(:quantity)
-        remaining = dispatch_plan_item.quantity - dispatched
-        remaining += quantity_was if quantity_was
-        errors.add(:quantity, "exceeds allocated quantity. Maximum allowed is #{remaining}") if quantity > remaining
+      def authorized_quantity
+        dispatch_authorizations.sum(:quantity)
       end
 
       def validate_dispatch_plan_status
@@ -52,41 +44,49 @@ module Cats
       def approve
         raise(StandardError, 'Dispatch has to be in draft state.') unless dispatch_status == Dispatch::DRAFT
 
-        # Check if dispatch has transactions
-        raise(StandardError, 'Dispatch has no transactions.') unless dispatch_transactions.count.positive?
+        # Check if dispatch has authorizations
+        raise(StandardError, 'Dispatch has no authorizations.') unless dispatch_authorizations.count.positive?
 
-        Dispatch.transaction do
-          # Commit transactions
-          dispatch_transactions.each(&:commit)
-          self.quantity = total_quantity
-          self.dispatch_status = Dispatch::APPROVED
-          save!
+        dispatches = Dispatch.where(dispatch_plan_item: dispatch_plan_item)
+        authorized = dispatches.inject(0) do |result, dispatch|
+          result += dispatch.authorized_quantity
+          result
         end
-      end
+        diff = authorized - dispatch_plan_item.quantity
+        error = "Total authorized quantity exceeds allocated quantity (Extra = #{diff})."
+        raise(StandardError, error) if diff.positive?
 
-      def start
-        raise(StandardError, 'Dispatch has to be approved first.') unless dispatch_status == Dispatch::APPROVED
-
-        self.dispatch_status = Dispatch::STARTED
+        self.dispatch_status = APPROVED
         save!
       end
 
-      def confirm
-        total = receipts.sum(:quantity)
-
-        unless total == quantity
-          diff = (quantity - total).abs
-          raise(
-            StandardError,
-            "There is an amount of #{diff} in the dispatch which is unaccounted for."
-          )
-        end
-
+      def start
         Dispatch.transaction do
-          self.dispatch_status = Dispatch::RECEIVED
-          receipts.each { |r| r.status = Receipt::CONFIRMED }
+          # Commit transactions
+          self.quantity = dispatch_transactions.sum(:quantity)
+          self.dispatch_status = STARTED
           save!
-          receipts.each(&:save!)
+          dispatch_transactions.each(&:commit)
+        end
+      end
+
+      def self.search_commodity(batch_no)
+        commodity = Commodity.find_by(batch_no: batch_no)
+        dispatches = Dispatch.includes(:dispatch_transactions)
+                             .joins(:transporter)
+                             .where(
+                               dispatch_status: [APPROVED, STARTED, ARRIVED, UNLOADED]
+                             )
+        dispatches.map do |dispatch|
+          {
+            batch_no: batch_no,
+            commodity_name: commodity.name,
+            quantity: dispatch.quantity,
+            unit: commodity.unit_abbreviation,
+            location: dispatch.transporter.name,
+            location_detail: "Plate No.: #{dispatch.plate_no}, Driver: #{dispatch.driver_name}",
+            stack: ''
+          }
         end
       end
     end

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

@@ -0,0 +1,13 @@
+module Cats
+  module Core
+    class DispatchAuthorization < Authorization
+      has_many :dispatch_transactions
+
+      def validate_dispatch_status
+        return unless dispatch
+
+        errors.add(:dispatch, 'is not in draft state.') unless dispatch.dispatch_status == Dispatch::DRAFT
+      end
+    end
+  end
+end

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

@@ -15,6 +15,7 @@ module Cats
       has_many :dispatches
       has_many :hub_authorizations
 
+      validates :reference_no, presence: true, uniqueness: true
       validates :commodity_status, presence: true, inclusion: { in: Commodity::COMMODITY_STATUSES }
       validates :quantity, presence: true, numericality: { greater_than: 0 }
       validates :status, presence: true, inclusion: { in: STATUSES }

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

@@ -2,10 +2,13 @@ module Cats
   module Core
     class DispatchTransaction < Transaction
       belongs_to :source, class_name: 'Cats::Core::Stack'
-      belongs_to :dispatch
+      belongs_to :dispatch_authorization
+
+      validates :source_id, uniqueness: { scope: :dispatch_authorization_id }
+      validate :validate_dispatch
+      validate :validate_source_quantity, :validate_authorized_quantity, unless: :skip_quantity_validation
 
       delegate(:code, to: :source, prefix: true)
-      delegate(:reference_no, to: :dispatch, prefix: true)
 
       def commit
         Transaction.transaction do
@@ -16,6 +19,40 @@ module Cats
           save!
         end
       end
+
+      def validate_dispatch
+        return unless dispatch_authorization
+
+        status = dispatch_authorization.dispatch.dispatch_status
+        errors.add(:base, 'Dispatch must be approved first.') if status == Dispatch::DRAFT
+      end
+
+      def validate_source_quantity
+        return unless quantity && source
+
+        total = DispatchTransaction.where(status: DRAFT, source: source).sum(:quantity)
+        diff = quantity - (source.quantity - total)
+        diff -= quantity_was if quantity_was
+        errors.add(:quantity, "exceeds source quantity by #{diff}") if diff.positive?
+      end
+
+      def validate_authorized_quantity
+        return unless quantity && dispatch_authorization
+
+        total = DispatchTransaction.where(dispatch_authorization: dispatch_authorization).sum(:quantity)
+        diff = dispatch_authorization.quantity - total
+        diff += quantity_was if quantity_was
+        errors.add(:quantity, "exceeds authorized quantity (Max. = #{diff}).") if quantity > diff
+      end
+
+      def skip_quantity_validation
+        # Quantity validation should be skipped if dispatch is already started.
+        return true unless dispatch_authorization
+
+        return true if status == COMMITTED
+
+        ![Dispatch::DRAFT, Dispatch::APPROVED].include?(dispatch_authorization.dispatch.dispatch_status)
+      end
     end
   end
 end

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

@@ -0,0 +1,26 @@
+module Cats
+  module Core
+    class ReceiptAuthorization < Authorization
+      has_many :receipt_transactions
+
+      validates :lost_quantity, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validate :validate_total_quantity
+
+      def validate_total_quantity
+        return unless dispatch && quantity
+
+        received = dispatch.receipt_authorizations.sum(:quantity) + dispatch.receipt_authorizations.sum(:lost_quantity)
+        diff = dispatch.quantity - received
+        diff += quantity_was if quantity_was
+        diff += lost_quantity_was if lost_quantity_was
+
+        errors.add(:quantity, "authorized is higher than dispatch quantity (Max = #{diff}).") if quantity > diff
+      end
+
+      def confirm
+        self.status = CONFIRMED
+        save!
+      end
+    end
+  end
+end

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

@@ -1,27 +1,29 @@
 module Cats
   module Core
     class ReceiptTransaction < Transaction
-      belongs_to :receipt
+      belongs_to :receipt_authorization
       belongs_to :destination, class_name: 'Cats::Core::Stack'
 
-      delegate(:code, to: :destination, prefix: true)
+      validates :transaction_date, presence: true
+      validates :quantity, presence: true, numericality: { greater_than: 0 }
+      validate :validate_receipt, :validate_quantity
 
-      def validate_quantity
-        return unless quantity.present? && destination.present? && receipt.present?
+      delegate(:code, to: :destination, prefix: true)
 
-        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)
+      def validate_receipt
+        return unless receipt_authorization
 
-        received -= quantity_was if quantity_was
+        status = receipt_authorization.status
+        errors.add(:receipt_authorization, 'must be confirmed.') if status == ReceiptAuthorization::AUTHORIZED
+      end
 
-        # Get quantity in hub authorization for source
-        available = authorized - received
+      def validate_quantity
+        return unless quantity && destination && receipt_authorization
 
-        errors.add(:quantity, "exceeds authorized quantity (Max = #{available}).") if quantity > available
+        total = ReceiptTransaction.where(receipt_authorization: receipt_authorization).sum(:quantity)
+        diff = receipt_authorization.quantity - total
+        diff += quantity_was if quantity_was
+        errors.add(:quantity, "exceeds authorized quantity (Max. = #{diff}).") if quantity > diff
       end
 
       def commit

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

@@ -146,6 +146,25 @@ module Cats
 
         store.save
       end
+
+      def self.search_commodity(batch_no)
+        commodity = Commodity.find_by(batch_no: batch_no)
+        stacks = Stack.joins(:commodity, store: :warehouse).where(
+          commodity: { batch_no: batch_no },
+          stack_status: Stack::ALLOCATED
+        )
+        stacks.map do |stack|
+          {
+            batch_no: batch_no,
+            commodity_name: commodity.name,
+            quantity: stack.quantity,
+            unit: commodity.unit_abbreviation,
+            location: stack.store.warehouse.name,
+            location_detail: stack.store.name,
+            stack: stack.code
+          }
+        end
+      end
     end
   end
 end

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

@@ -12,41 +12,11 @@ module Cats
       validates :transaction_date, :quantity, :status, presence: true
       validates :quantity, numericality: { greater_than: 0 }
       validates :status, inclusion: { in: STATUSES }
-      validate :validate_quantity, unless: :skip_quantity_validation
-
-      def validate_quantity
-        return unless quantity.present? && source.present? && dispatch.present?
-
-        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
-
-        # 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, "exceeds authorized quantity (Max = #{available}).") if quantity > available
-      end
 
       def commit
         raise(NotImplementedError, 'Method should be implemented in child classes.')
       end
 
-      def skip_quantity_validation
-        # Quantity validation should be skipped if we are commiting transactions.
-        (
-          instance_of?(Cats::Core::DispatchTransaction) &&
-          dispatch &&
-          status == COMMITTED
-        ) || (
-          instance_of?(Cats::Core::ReceiptTransaction) &&
-          receipt &&
-          receipt.status == Cats::Core::Receipt::STACKING
-        )
-      end
-
       def set_status
         return unless new_record?
 

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

@@ -36,7 +36,7 @@ module Cats
 
         errors.add(:status, 'cannot be set to "APPROVED" because the order has no items.') if status == APPROVED
       end
-      
+
       def approve(user)
         raise(StandardError, 'Transport order is already approved.') if status == APPROVED
 

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

@@ -0,0 +1,8 @@
+module Cats
+  module Core
+    class DispatchAuthorizationSerializer < ActiveModel::Serializer
+      attributes :id, :dispatch_id, :dispatch_reference_no, :store_id, :store_name, :quantity, :authorized_by_id,
+                 :authorizer_full_name
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,8 @@
+module Cats
+  module Core
+    class ReceiptAuthorizationSerializer < ActiveModel::Serializer
+      attributes :id, :dispatch_id, :dispatch_reference_no, :store_id, :store_name, :quantity, :lost_quantity, :remark,
+                 :status, :authorized_by_id, :authorizer_full_name
+    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, :receipt_id, :dispatch_reference, :destination_id, :destination_code, :quantity,
+      attributes :id, :receipt_authorization_id, :dispatch_reference, :destination_id, :destination_code, :quantity,
                  :transaction_date, :status
 
       def dispatch_reference
-        object.receipt.dispatch.reference_no
+        object.receipt_authorization.dispatch.reference_no
       end
     end
   end

data/config/routes.rb

@@ -99,7 +99,8 @@ Cats::Core::Engine.routes.draw do
   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 'dispatch_authorizations', controller: :dispatch_authorizations, action: :index
+      get 'receipt_authorizations', controller: :receipt_authorizations, action: :index
       get 'receipts', controller: :receipts, action: :index
       get 'lost', controller: :lost_commodities, action: :index
       get 'commodity'
@@ -109,6 +110,20 @@ Cats::Core::Engine.routes.draw do
     end
   end
 
+  resources :dispatch_authorizations, except: %i[index destory] do
+    member do
+      get 'transactions', controller: :dispatch_transactions, action: :index
+      post 'confirm', controller: :dispatch_authorizations, action: :confirm
+    end
+  end
+
+  resources :receipt_authorizations, except: %i[index destroy] do
+    member do
+      get 'transactions', controller: :receipt_transactions, action: :index
+      post 'confirm', controller: :receipt_authorizations, action: :confirm
+    end
+  end
+
   post(
     'dispatch_transactions/allocation',
     controller: :dispatch_transactions,
@@ -116,13 +131,6 @@ Cats::Core::Engine.routes.draw do
     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
-      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/round_plans', controller: :round_plans, action: :index, as: :round_plans_plan

data/db/migrate/20210718043401_create_cats_core_dispatch_plan_items.rb

@@ -1,6 +1,7 @@
 class CreateCatsCoreDispatchPlanItems < ActiveRecord::Migration[6.1]
   def change
     create_table :cats_core_dispatch_plan_items do |t|
+      t.string :reference_no, null: false, unique: true
       t.references :dispatch_plan,
                    null: false,
                    index: { name: 'dpi_on_dp_indx' },

data/db/migrate/20210718045516_create_cats_core_dispatches.rb

@@ -14,6 +14,10 @@ class CreateCatsCoreDispatches < ActiveRecord::Migration[6.1]
       t.string :driver_name, null: false
       t.string :driver_phone, null: false
       t.float :quantity, null: false, default: 0
+      t.references :unit,
+                   null: false,
+                   index: { name: 'unit_on_dispatches_indx' },
+                   foreign_key: { to_table: :cats_core_unit_of_measures } 
       t.string :commodity_status, null: false, default: 'Good'
       t.string :remark
       t.references :prepared_by,

data/db/migrate/20210718055414_create_cats_core_dispatch_authorizations.rb

@@ -0,0 +1,22 @@
+class CreateCatsCoreDispatchAuthorizations < ActiveRecord::Migration[7.0]
+  def change
+    create_table :cats_core_dispatch_authorizations do |t|
+      t.references :dispatch,
+                   null: false,
+                   index: { name: 'dispatch_on_da_indx' },
+                   foreign_key: { to_table: :cats_core_dispatches }
+      t.references :store,
+                   null: false,
+                   index: { name: 'store_on_da_indx' },
+                   foreign_key: { to_table: :cats_core_stores }
+      t.float :quantity, null: false
+      t.string :status, null: false, default: 'Authorized'
+      t.references :authorized_by,
+                   null: false,
+                   index: { name: 'ab_on_da_indx' },
+                   foreign_key: { to_table: :cats_core_users }
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20210718202957_create_cats_core_dispatch_transactions.rb

@@ -5,15 +5,21 @@ class CreateCatsCoreDispatchTransactions < ActiveRecord::Migration[6.1]
                    null: false,
                    index: { name: 'stack_on_dt_indx' },
                    foreign_key: { to_table: :cats_core_stacks }
-      t.references :dispatch,
+      t.references :dispatch_authorization,
                    null: false,
-                   index: { name: 'dispatch_on_dt_indx' },
-                   foreign_key: { to_table: :cats_core_dispatches }
+                   index: { name: 'da_on_dt_indx' },
+                   foreign_key: { to_table: :cats_core_dispatch_authorizations }
       t.date :transaction_date, null: false
       t.float :quantity, null: false
       t.string :status, null: false, default: 'Draft'
 
       t.timestamps
     end
+    add_index(
+      :cats_core_dispatch_transactions,
+      [:source_id, :dispatch_authorization_id],
+      unique: true,
+      name: 'sda_on_dt_uniq_indx'
+    )
   end
 end

data/db/migrate/20210727074646_create_cats_core_receipt_authorizations.rb

@@ -0,0 +1,24 @@
+class CreateCatsCoreReceiptAuthorizations < ActiveRecord::Migration[6.1]
+  def change
+    create_table :cats_core_receipt_authorizations do |t|
+      t.references :dispatch,
+                   null: false,
+                   index: { name: 'dispatch_on_receipt_authorizations_indx' },
+                   foreign_key: { to_table: :cats_core_dispatches }
+      t.references :store,
+                   null: false,
+                   index: { name: 'store_on_ra_indx' },
+                   foreign_key: { to_table: :cats_core_stores } 
+      t.float :quantity, null: false
+      t.float :lost_quantity, null: false, default: 0
+      t.string :status, null: false, default: 'Authorized'
+      t.string :remark
+      t.references :authorized_by,
+                   null: false,
+                   index: { name: 'ab_on_receipt_authorizations_indx' },
+                   foreign_key: { to_table: :cats_core_users }
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20210814160628_create_cats_core_receipt_transactions.rb

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

data/lib/cats/core/version.rb

@@ -1,5 +1,5 @@
 module Cats
   module Core
-    VERSION = '1.4.19'.freeze
+    VERSION = '1.4.22'.freeze
   end
 end

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

@@ -0,0 +1,26 @@
+FactoryBot.define do
+  factory :dispatch_authorization, class: 'Cats::Core::DispatchAuthorization' do
+    transient do
+      s { create(:store) }
+      stack { create(:stack, quantity: 100, store: s) }
+    end
+    dispatch
+    store { s }
+    quantity { 100 }
+    status { Cats::Core::ReceiptAuthorization::AUTHORIZED }
+    authorized_by factory: :user
+
+    trait :approved do
+      after(:create) do |obj|
+        obj.dispatch.approve
+      end
+    end
+
+    trait :with_transaction do
+      after(:create) do |obj, options|
+        obj.dispatch.approve
+        create(:dispatch_transaction, dispatch_authorization: obj, source: options.stack, quantity: 100)
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 FactoryBot.define do
   factory :dispatch_plan_item, class: 'Cats::Core::DispatchPlanItem' do
+    reference_no { FFaker::Name.name }
     source factory: :location
     destination factory: :location
     dispatch_plan

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

@@ -4,14 +4,9 @@ FactoryBot.define 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
+    association :dispatch_authorization, :approved
     transaction_date { Date.today }
-    quantity { 10 }
+    quantity { 100 }
     status { Cats::Core::Transaction::DRAFT }
   end
 end

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

@@ -2,7 +2,6 @@ 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
@@ -11,6 +10,7 @@ FactoryBot.define do
       create(:hub_authorization, dispatch_plan_item: plan_item, quantity: 100, store: stack.store)
       plan_item
     end
+    unit factory: :unit_of_measure
     transporter
     plate_no { FFaker::Name.name }
     driver_name { FFaker::Name.name }
@@ -19,8 +19,27 @@ FactoryBot.define do
     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?
+    trait :with_authorization do
+      after(:create) do |dispatch, options|
+        create(:dispatch_authorization, dispatch: dispatch, store: options.stack.store)
+      end
+    end
+
+    trait :with_transaction do
+      after(:create) do |dispatch, options|
+        authorization = create(:dispatch_authorization, dispatch: dispatch, store: options.stack.store)
+        dispatch.approve
+        create(:dispatch_transaction, dispatch_authorization: authorization, source: options.stack, quantity: 100)
+      end
+    end
+
+    trait :started do
+      after(:create) do |dispatch, options|
+        authorization = create(:dispatch_authorization, dispatch: dispatch, store: options.stack.store)
+        dispatch.approve
+        create(:dispatch_transaction, dispatch_authorization: authorization, source: options.stack, quantity: 100)
+        dispatch.start
+      end
     end
   end
 end

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

@@ -0,0 +1,19 @@
+FactoryBot.define do
+  factory :receipt_authorization, class: 'Cats::Core::ReceiptAuthorization' do
+    dispatch do
+      dispatch = create(:dispatch, :with_transaction)
+      dispatch.start
+      dispatch
+    end
+    store
+    quantity { 100 }
+    lost_quantity { 0 }
+    remark { FFaker::Name.name }
+    status { Cats::Core::ReceiptAuthorization::AUTHORIZED }
+    authorized_by factory: :user
+
+    trait :confirmed do
+      status { Cats::Core::ReceiptAuthorization::CONFIRMED }
+    end
+  end
+end

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

@@ -1,27 +1,7 @@
 FactoryBot.define do
   factory :receipt_transaction, class: 'Cats::Core::ReceiptTransaction' do
-    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
+    association :receipt_authorization, :confirmed
+    destination factory: :stack
     transaction_date { Date.today }
     quantity { 100 }
     status { Cats::Core::Transaction::DRAFT }

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

@@ -3,6 +3,6 @@ FactoryBot.define do
     region factory: :location
     source factory: :woreda
     destination factory: :woreda
-    name { "#{source.name} - #{destination.name}"}
+    name { "#{source.name} - #{destination.name}" }
   end
 end

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

@@ -10,6 +10,6 @@ FactoryBot.define do
     store
     commodity_status { Cats::Core::Commodity::GOOD }
     stack_status { Cats::Core::Stack::RESERVED }
-    quantity { 50 }
+    quantity { 100 }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cats_core
 version: !ruby/object:Gem::Version
-  version: 1.4.19
+  version: 1.4.22
 platform: ruby
 authors:
 - Henock L.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-16 00:00:00.000000000 Z
+date: 2022-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -235,6 +235,7 @@ files:
 - 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_authorizations_controller.rb
 - app/controllers/cats/core/dispatch_plan_items_controller.rb
 - app/controllers/cats/core/dispatch_plans_controller.rb
 - app/controllers/cats/core/dispatch_transactions_controller.rb
@@ -243,8 +244,8 @@ files:
 - app/controllers/cats/core/lost_commodities_controller.rb
 - app/controllers/cats/core/menus_controller.rb
 - app/controllers/cats/core/notifications_controller.rb
+- app/controllers/cats/core/receipt_authorizations_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/round_plans_controller.rb
 - app/controllers/cats/core/routes_controller.rb
@@ -258,6 +259,7 @@ files:
 - app/jobs/cats/core/application_job.rb
 - app/models/cats/core/application_module.rb
 - app/models/cats/core/application_record.rb
+- app/models/cats/core/authorization.rb
 - app/models/cats/core/beneficiary.rb
 - app/models/cats/core/beneficiary_category.rb
 - app/models/cats/core/beneficiary_plan_item.rb
@@ -268,6 +270,7 @@ files:
 - app/models/cats/core/contract_item.rb
 - app/models/cats/core/currency.rb
 - app/models/cats/core/dispatch.rb
+- app/models/cats/core/dispatch_authorization.rb
 - app/models/cats/core/dispatch_plan.rb
 - app/models/cats/core/dispatch_plan_item.rb
 - app/models/cats/core/dispatch_transaction.rb
@@ -289,7 +292,7 @@ files:
 - app/models/cats/core/program.rb
 - app/models/cats/core/purchase_order.rb
 - app/models/cats/core/ration.rb
-- app/models/cats/core/receipt.rb
+- app/models/cats/core/receipt_authorization.rb
 - app/models/cats/core/receipt_transaction.rb
 - app/models/cats/core/rhn_request.rb
 - app/models/cats/core/role.rb
@@ -328,12 +331,14 @@ files:
 - app/serializers/cats/core/commodity_category_serializer.rb
 - app/serializers/cats/core/commodity_serializer.rb
 - app/serializers/cats/core/currency_serializer.rb
+- app/serializers/cats/core/dispatch_authorization_serializer.rb
 - app/serializers/cats/core/dispatch_plan_item_serializer.rb
 - app/serializers/cats/core/dispatch_plan_serializer.rb
 - app/serializers/cats/core/dispatch_serializer.rb
 - 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/receipt_authorization_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
@@ -349,7 +354,6 @@ files:
 - app/services/cats/core/dispatch_service.rb
 - app/services/cats/core/menu_service.rb
 - app/services/cats/core/notification_service.rb
-- app/services/cats/core/receipt_service.rb
 - app/services/cats/core/round_plan_service.rb
 - app/services/cats/core/space_service.rb
 - app/services/cats/core/stack_service.rb
@@ -387,10 +391,11 @@ files:
 - db/migrate/20210718043328_create_cats_core_dispatch_plans.rb
 - db/migrate/20210718043401_create_cats_core_dispatch_plan_items.rb
 - db/migrate/20210718045516_create_cats_core_dispatches.rb
+- db/migrate/20210718055414_create_cats_core_dispatch_authorizations.rb
 - db/migrate/20210718202957_create_cats_core_dispatch_transactions.rb
 - 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/20210727074646_create_cats_core_receipt_authorizations.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
@@ -435,6 +440,7 @@ files:
 - spec/factories/cats/core/commodity_substitutions.rb
 - spec/factories/cats/core/contract_items.rb
 - spec/factories/cats/core/currencies.rb
+- spec/factories/cats/core/dispatch_authorizations.rb
 - spec/factories/cats/core/dispatch_plan_items.rb
 - spec/factories/cats/core/dispatch_plans.rb
 - spec/factories/cats/core/dispatch_transactions.rb
@@ -457,8 +463,8 @@ files:
 - spec/factories/cats/core/programs.rb
 - spec/factories/cats/core/purchase_orders.rb
 - spec/factories/cats/core/rations.rb
+- spec/factories/cats/core/receipt_authorizations.rb
 - spec/factories/cats/core/receipt_transactions.rb
-- spec/factories/cats/core/receipts.rb
 - spec/factories/cats/core/rhn_requests.rb
 - spec/factories/cats/core/role_menus.rb
 - spec/factories/cats/core/roles.rb

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

@@ -1,45 +0,0 @@
-module Cats
-  module Core
-    class ReceiptsController < ApplicationController
-      include Common
-
-      def index
-        super do
-          Receipt.where(dispatch_id: params[:id])
-        end
-      end
-
-      def create
-        super do
-          service = ReceiptService.new
-          receipt = service.init(model_params)
-          receipt
-        end
-      end
-
-      def start_stacking
-        receipt = Receipt.find(params[:id])
-        service = ReceiptService.new
-        result = service.start_stacking(receipt)
-        render json: { success: true, data: serialize(result) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
-      end
-
-      def finish_stacking
-        receipt = Receipt.find(params[:id])
-        service = ReceiptService.new
-        result = service.finish_stacking(receipt)
-        render json: { success: true, data: serialize(result) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
-      end
-
-      private
-
-      def model_params
-        params.require(:payload).permit(:dispatch_id, :quantity, :commodity_status, :status, :remark, :prepared_by_id)
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module Cats
-  module Core
-    class Receipt < ApplicationRecord
-      # Receipt status
-      DRAFT = 'Draft'.freeze
-      CONFIRMED = 'Confirmed'.freeze
-      STACKING = 'Stacking'.freeze
-      STACKED = 'Stacked'.freeze
-      RECEIPT_STATUSES = [DRAFT, CONFIRMED, STACKING, STACKED].freeze
-
-      belongs_to :dispatch
-      belongs_to :prepared_by, class_name: 'Cats::Core::User'
-      has_many :receipt_transactions
-
-      validates :quantity, :commodity_status, :status, presence: true
-      validates :quantity, numericality: { greater_than: 0 }
-      validates :status, inclusion: { in: RECEIPT_STATUSES }
-      validates :commodity_status, inclusion: { in: Cats::Core::Commodity::COMMODITY_STATUSES }
-      validate :validate_dispatch_status, :validate_total_quantity
-
-      delegate(:reference_no, to: :dispatch, prefix: true)
-      delegate(:email, to: :prepared_by, prefix: true)
-
-      def validate_dispatch_status
-        return unless dispatch
-
-        statuses = [Cats::Core::Dispatch::STARTED, Cats::Core::Dispatch::RECEIVED]
-        return if statuses.include?(dispatch.dispatch_status)
-
-        errors.add(:dispatch, 'should be in "Started" state.')
-      end
-
-      def validate_total_quantity
-        return unless dispatch && quantity
-
-        received = dispatch.receipts.sum(:quantity) + dispatch.lost_commodities.sum(:quantity)
-        diff = dispatch.quantity - received
-        diff += quantity_was if quantity_was
-
-        errors.add(:quantity, "total is higher than dispatch quantity (Max = #{diff}).") if quantity > diff
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-module Cats
-  module Core
-    class ReceiptService
-      def start_stacking(receipt)
-        raise(StandardError, 'Receipt should be confirmed.') unless receipt.status == Cats::Core::Receipt::CONFIRMED
-
-        raise(StandardError, 'There are no stack assignments in receipt.') if receipt.receipt_transactions.count.zero?
-
-        receipt.status = Cats::Core::Receipt::STACKING
-        receipt.save!
-        receipt
-      end
-
-      def finish_stacking(receipt)
-        unless receipt.status == Cats::Core::Receipt::STACKING
-          raise(StandardError, 'Receipt should be in stacking state.')
-        end
-
-        receipt.receipt_transactions.each(&:commit)
-        receipt.status = Cats::Core::Receipt::STACKED
-        receipt.save!
-        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/db/migrate/20210727074646_create_cats_core_receipts.rb

@@ -1,20 +0,0 @@
-class CreateCatsCoreReceipts < ActiveRecord::Migration[6.1]
-  def change
-    create_table :cats_core_receipts do |t|
-      t.references :dispatch,
-                   null: false,
-                   index: { name: 'dispatch_on_receipts_indx' },
-                   foreign_key: { to_table: :cats_core_dispatches }
-      t.float :quantity, null: false
-      t.string :commodity_status, null: false, default: 'Good'
-      t.string :status, null: false, default: 'Draft'
-      t.string :remark
-      t.references :prepared_by,
-                   null: false,
-                   index: { name: 'pb_on_receipts_indx' },
-                   foreign_key: { to_table: :cats_core_users }
-
-      t.timestamps
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-FactoryBot.define do
-  factory :receipt, class: 'Cats::Core::Receipt' do
-    dispatch do
-      dispatch = create(:dispatch)
-      dispatch.approve
-      dispatch.start
-      dispatch
-    end
-    quantity { 100 }
-    commodity_status { Cats::Core::Commodity::GOOD }
-    status { Cats::Core::Receipt::DRAFT }
-    remark { FFaker::Name.name }
-    prepared_by factory: :user
-  end
-end