cats_core 1.4.21 → 1.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88b37ea0943ecb3db77fd873889665d4a58f990cb712a75ca258897cc448bc6c
-  data.tar.gz: c4f897f6a36c0a5ce076d5ed144d342b82ef57ac8f3e226df6de84efa4f71daa
+  metadata.gz: 3dd00b147a4dfa4ab46e10d7961b4291fbdb39ed68e49a0766e69a4a4d22704a
+  data.tar.gz: 1c37f11f41f76263cb197cdd881b820475a38e8addf1424fce593287ab1e30ad
 SHA512:
-  metadata.gz: 3c706230ac9911c572bdb611f18a65f7e61afaf01f94c4a901298391c7f54b7637be9b9b54b02a63e817e621916931fffe7eca14481ecca649fc21af0f1f553a
-  data.tar.gz: c90b1ec96db1ccc7f20fae099366a4f1f5660905234a287ee7a6ccf7de16602e21c8dc653df35d1cfc5b1b722e8d2deace2374685a2c42b08263d3b113790c48
+  metadata.gz: ce78191aa4dde60ba521f32f95a87088f7e9380fcba3e3a05f2cb570c4fd722b6b1962ddff54ab76ea0278552b1640f3a72b0e96571e0160b096bc49b00abd56
+  data.tar.gz: f5e36206d35c62b26cd16bdcaeea9f11c711d90c2c68b6f5c5eeb4e174621c4ad6e8ef28f0082ad74cb505e82bbc44876cd67da9be92b045beebfd0f22c1b269

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

@@ -0,0 +1,35 @@
+module Cats
+  module Core
+    class DispatchAuthorizationsController < ApplicationController
+      include Common
+
+      def index
+        super do
+          DispatchAuthorization.where(dispatch_id: params[:id])
+        end
+      end
+
+      def confirm
+        service = AuthorizationService.new
+        authorization = service.confirm(params[:id])
+        render json: { success: true, data: serialize(authorization) }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      def storekeeper_authorizations
+        storekeeper = User.find(params[:id])
+        stores = storekeeper.stores
+        authorizations = DispatchAuthorization.joins(:dispatch)
+                                              .where(store: stores, dispatch: { dispatch_status: Dispatch::APPROVED })
+        render json: { success: true, data: serialize(authorizations) }
+      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

@@ -43,6 +43,11 @@ module Cats
         render json: { success: false, error: e.message }
       end
 
+      def filter
+        query = Dispatch.ransack(params[:q])
+        render json: { success: true, data: serialize(query.result) }
+      end
+
       def search
         data = @service.search(current_user, params[:status])
         render json: { success: true, data: serialize(data) }
@@ -60,8 +65,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/lost_commodities_controller.rb

@@ -5,12 +5,12 @@ module Cats
 
       def index
         super do
-          LostCommodity.where(dispatch_id: params[:id])
+          LostCommodity.where(receipt_authorization_id: params[:id])
         end
       end
 
       def model_params
-        params.require(:payload).permit(:dispatch_id, :quantity, :commodity_status, :remark)
+        params.require(:payload).permit(:receipt_authorization_id, :quantity, :remark)
       end
     end
   end

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

@@ -0,0 +1,27 @@
+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, :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/controllers/cats/core/receipts_controller.rb

@@ -5,40 +5,14 @@ module Cats
 
       def index
         super do
-          Receipt.where(dispatch_id: params[:id])
+          Receipt.where(receipt_authorization_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)
+        params.require(:payload).permit(:receipt_authorization_id, :commodity_status, :quantity, :remark)
       end
     end
   end

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

@@ -0,0 +1,77 @@
+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)
+      delegate(:dispatch_status, to: :dispatch)
+      delegate(:plate_no, to: :dispatch)
+      delegate(:driver_name, to: :dispatch)
+
+      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
+        if instance_of?(DispatchAuthorization)
+          raise(StandardError, 'Authorization does not have transactions.') if transactions.blank?
+
+          transactions.each(&:commit)
+          # count = transactions.where(status: Transaction::DRAFT).count
+          # raise(StandardError, 'There are uncommitted transactions.') if count.positive?
+        elsif instance_of?(ReceiptAuthorization)
+          raise(StandardError, 'Authorization does not have receipts.') unless receipts.count.positive?
+
+          total_received = receipts.sum(:quantity)
+          total_lost = lost_commodities.sum(:quantity)
+          diff = quantity - (total_received + total_lost)
+          raise(StandardError, "A quantity of #{diff} is unaccounted for.") unless diff.zero?
+
+          self.received_quantity = total_received
+        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

@@ -3,44 +3,36 @@ module Cats
     class Dispatch < ApplicationRecord
       DRAFT = 'Draft'.freeze
       APPROVED = 'Approved'.freeze
+      READY_TO_START = 'Ready to Start'.freeze
       STARTED = 'Started'.freeze
       ARRIVED = 'Arrived'.freeze
       UNLOADED = 'Unloaded'.freeze
       RECEIVED = 'Received'.freeze
 
-      DISPATCH_STATUSES = [DRAFT, APPROVED, STARTED, ARRIVED, UNLOADED, RECEIVED].freeze
+      DISPATCH_STATUSES = [DRAFT, APPROVED, READY_TO_START, STARTED, ARRIVED, UNLOADED, RECEIVED].freeze
 
       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 :receipt_transactions, through: :receipts
-      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
@@ -53,42 +45,32 @@ 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 = 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
-
-      def start
-        raise(StandardError, 'Dispatch has to be approved first.') unless dispatch_status == Dispatch::APPROVED
+        diff = authorized - dispatch_plan_item.quantity
+        error = "Total authorized quantity exceeds allocated quantity (Extra = #{diff})."
+        raise(StandardError, error) if diff.positive?
 
-        self.dispatch_status = STARTED
+        self.dispatch_status = APPROVED
         save!
       end
 
-      def confirm
-        total = receipts.sum(:quantity)
+      def all_authorizations_confirmed?
+        statuses = dispatch_authorizations.map(&:status).uniq
+        return true if statuses.length == 1 && statuses[0] == Authorization::CONFIRMED
 
-        unless total == quantity
-          diff = (quantity - total).abs
-          raise(
-            StandardError,
-            "There is an amount of #{diff} in the dispatch which is unaccounted for."
-          )
-        end
+        false
+      end
 
-        Dispatch.transaction do
-          self.dispatch_status = RECEIVED
-          receipts.each { |r| r.status = Receipt::CONFIRMED }
-          save!
-          receipts.each(&:save!)
-        end
+      def start
+        self.dispatch_status = STARTED
+        save!
       end
 
       def self.search_commodity(batch_no)
@@ -102,7 +84,7 @@ module Cats
           {
             batch_no: batch_no,
             commodity_name: commodity.name,
-            quantity: dispatch.total_quantity,
+            quantity: dispatch.quantity,
             unit: commodity.unit_abbreviation,
             location: dispatch.transporter.name,
             location_detail: "Plate No.: #{dispatch.plate_no}, Driver: #{dispatch.driver_name}",

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/lost_commodity.rb

@@ -1,10 +1,9 @@
 module Cats
   module Core
     class LostCommodity < ApplicationRecord
-      belongs_to :dispatch
+      belongs_to :receipt_authorization
 
-      validates :quantity, presence: true
-      validates :commodity_status, presence: true, inclusion: { in: Commodity::COMMODITY_STATUSES }
+      validates :quantity, presence: true, numericality: { greater_than: 0 }
     end
   end
 end

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

@@ -1,44 +1,10 @@
 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 :receipt_authorization
 
-      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
+      validates :commodity_status, presence: true, inclusion: { in: Commodity::COMMODITY_STATUSES }
+      validates :quantity, presence: true, numericality: { greater_than: 0 }
     end
   end
 end

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

@@ -0,0 +1,22 @@
+module Cats
+  module Core
+    class ReceiptAuthorization < Authorization
+      has_many :receipts
+      has_many :lost_commodities
+      has_many :receipt_transactions
+
+      validates :received_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)
+        diff = dispatch.quantity - received
+        diff += quantity_was if quantity_was
+
+        errors.add(:quantity, "authorized is higher than dispatch quantity (Max = #{diff}).") if quantity > diff
+      end
+    end
+  end
+end

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

@@ -1,27 +1,30 @@
 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)
+      delegate(:dispatch_reference_no, to: :receipt_authorization)
 
-        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