cats_core 1.1.34 → 1.1.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04aa5725df06bf149cf057515dd11ef721dc9511b9aa9555cd2dd311ad9e96ff
-  data.tar.gz: ec1393337a6276fec08d3897618bb2ed345f66dd027a8a07efc59544bcd326d6
+  metadata.gz: 05d36c2ff3f71d11f2d601ae469f69b4db03ae956e98e5ea6e7fc11e230ca918
+  data.tar.gz: feb9cd6e23c14759ab5c7a423af1669d7d017de9eefa8e8cf602ca36b94ff0e7
 SHA512:
-  metadata.gz: d5b97bdff8990988dd0bebeba15e24fadc28328970e1343f36617c3ee93a149af2470320ad8b7adafca36dcfddcb927acbed34e67b325dbb3828e2941ab5f9cc
-  data.tar.gz: ec0011655502fd35e6313bd4e5f079557cc58de783d093d640e122fbcd894bbcca459225ebafdc83f7c4c2770a116477dd4f09061ee33c5fadeee0e32790445d
+  metadata.gz: d52633ea04e36f159602d53ec10d8e6664921238328e80bd85b6587dbbc5ecc1aade3f64a0cb7d8ae0ced07b9b4657f27be83d66906be5c79b1f66fce51ce359
+  data.tar.gz: 833963237bc5fa5c84da07a7f2e691f47ac379df36ef0df434f4de308205109bc3dcc40b77a1da2433f260f3b6a104486eca9c01888364d7d73ff9a8d0afaa41

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

@@ -31,8 +31,8 @@ module Cats
       end
 
       def approve
-        dispatch = @service.approve(@dispatch)
-        render json: { success: true, data: serialize(dispatch) }
+        @dispatch.approve
+        render json: { success: true, data: serialize(@dispatch) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
       end
@@ -45,8 +45,8 @@ module Cats
       end
 
       def confirm
-        dispatch = @service.confirm(@dispatch)
-        render json: { success: true, data: serialize(dispatch) }
+        @dispatch.confirm
+        render json: { success: true, data: serialize(@dispatch) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
       end

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

@@ -13,13 +13,62 @@ module Cats
       validates :commodity_status, :allocation_status, presence: true
       validates :reference_no, presence: true, uniqueness: true
       validates :quantity, presence: true, numericality: { greater_than: 0 }
-      validates :commodity_status, inclusion: { in: Cats::Core::Commodity::COMMODITY_STATUSES }
+      validates :commodity_status, inclusion: { in: Commodity::COMMODITY_STATUSES }
       validates :allocation_status, inclusion: { in: ALLOCATION_STATUSES }
+      validate :validate_quantity_against_items, :validate_quantity_against_commodity,
+               :validate_quantity_against_request, :validate_request_status, :validate_commodity_status
 
       delegate(:reference_no, to: :rhn_request, prefix: :rhn, allow_nil: true)
       delegate(:batch_no, to: :commodity, prefix: true)
       delegate(:name, to: :source, prefix: true)
       delegate(:location_type, to: :source, prefix: true)
+
+      def validate_quantity_against_items
+        return unless quantity
+
+        return unless quantity_changed?
+
+        allocated = allocation_items.sum(:quantity)
+        errors.add(:quantity, "is below items quantity. Minimum allowed is #{allocated}") if quantity < allocated
+      end
+
+      def validate_quantity_against_commodity
+        return unless quantity && commodity
+
+        allocated = Allocation.where(commodity: commodity).sum(:quantity)
+        remaining = commodity.quantity - allocated
+
+        remaining += quantity_was if quantity_was
+        errors.add(:quantity, "exceeds commodity quantity. Maximum allowed is #{remaining}") if quantity > remaining
+      end
+
+      def validate_quantity_against_request
+        return unless quantity && rhn_request
+
+        errors.add(:quantity, 'is not equal to requested quantity.') if quantity != rhn_request.quantity
+      end
+
+      def validate_request_status
+        return unless rhn_request
+
+        errors.add(:rhn_request, 'should be approved first.') if rhn_request.status != RhnRequest::APPROVED
+      end
+
+      def validate_commodity_status
+        return unless commodity
+
+        errors.add(:commodity, 'should be approved first.') unless commodity.approved
+      end
+
+      def approve
+        raise(StandardError, 'Allocation already approved.') if allocation_status == Allocation::APPROVED
+
+        item_quantity = allocation_items.sum(:quantity)
+        raise(StandardError, 'Allocation quantity and items quantity do not match.') if quantity != item_quantity
+
+        self.allocation_status = Allocation::APPROVED
+        save!
+      end
     end
   end
 end

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

@@ -6,7 +6,8 @@ module Cats
 
       validates :from, :to, presence: true
       validates :quantity, presence: true, numericality: { greater_than: 0 }
-      validate :validate_source_and_destination
+      validate :validate_source_and_destination, :validate_quantity
+      validate :validate_allocation_status, on: %i[create update]
 
       def validate_source_and_destination
         return unless allocation.present? && destination.present?
@@ -14,6 +15,25 @@ module Cats
         errors.add(:base, 'source and destination cannot be the same') if allocation.source == destination
       end
 
+      def validate_quantity
+        return unless quantity && allocation
+
+        return unless quantity_changed?
+
+        allocated = AllocationItem.where(allocation: allocation).sum(:quantity)
+        remaining = allocation.quantity - allocated
+        remaining += quantity_was if quantity_was
+        errors.add(:quantity, "exceeds allocated quantity. Maximum allowed is #{remaining}") if quantity > remaining
+      end
+
+      def validate_allocation_status
+        return unless allocation
+
+        return unless allocation.allocation_status == Cats::Core::Allocation::APPROVED
+
+        errors.add(:allocation, 'is alreay approved. Changes are not allowed at this point.')
+      end
+
       delegate(:name, to: :destination, prefix: true)
       delegate(:reference_no, to: :allocation, prefix: true)
       delegate(:location_type, to: :destination, prefix: true)

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

@@ -20,7 +20,7 @@ module Cats
       validates :reference_no, uniqueness: true
       validates :quantity, numericality: { greater_than: 0 }
       validates :commodity_status, inclusion: { in: Cats::Core::Commodity::COMMODITY_STATUSES }
-      validate :validate_quantity
+      validate :validate_quantity, :validate_allocation_status
 
       delegate(:name, to: :transporter, prefix: true)
       delegate(:email, to: :prepared_by, prefix: true)
@@ -32,8 +32,57 @@ module Cats
 
         dispatched = Dispatch.where(allocation_item: allocation_item).sum(:quantity)
         remaining = allocation_item.quantity - dispatched
+        remaining += quantity_was if quantity_was
         errors.add(:quantity, "exceeds allocated quantity. Maximum allowed is #{remaining}") if quantity > remaining
       end
+
+      def validate_allocation_status
+        return unless allocation_item
+
+        status = allocation_item.allocation.allocation_status
+        errors.add(:allocation_item, 'should be approved first.') unless status == Allocation::APPROVED
+      end
+
+      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?
+
+        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!
+      end
+
+      def start
+        raise(StandardError, 'Dispatch has to be approved first.') unless dispatch_status == Dispatch::APPROVED
+
+        self.dispatch_status = Dispatch::STARTED
+        save!
+        transactions = DispatchTransaction.where(destination_id: id)
+        transactions.each(&:commit)
+      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
+
+        Dispatch.transaction do
+          self.dispatch_status = Dispatch::RECEIVED
+          receipts.each { |r| r.status = Receipt::CONFIRMED }
+          save!
+          receipts.each(&:save!)
+        end
+      end
     end
   end
 end

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

@@ -35,15 +35,9 @@ module Cats
 
         received = dispatch.receipts.sum(:quantity)
         diff = dispatch.quantity - received
-        if new_record?
-          return if quantity <= diff
+        diff += quantity_was if quantity_was
 
-          errors.add(:quantity, "total is higher than dispatch quantity (Max = #{diff}).")
-        else
-          return unless diff.negative?
-
-          errors.add(:quantity, "total is higher than dispatch quantity (Max = #{diff.abs}).")
-        end
+        errors.add(:quantity, "total is higher than dispatch quantity (Max = #{diff}).") if quantity > diff
       end
     end
   end

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

@@ -1,13 +1,40 @@
 module Cats
   module Core
     class RhnRequest < ApplicationRecord
+      DRAFT = 'Draft'.freeze
+      APPROVED = 'Approved'.freeze
+      STATUSES = [DRAFT, APPROVED].freeze
+
       belongs_to :commodity
 
       validates :reference_no, :request_date, :quantity, presence: true
       validates :reference_no, uniqueness: true
       validates :quantity, numericality: { greater_than: 0 }
+      validates :status, presence: true, inclusion: { in: STATUSES }
+      validate :validate_commodity_status, :validate_quantity
 
       delegate(:batch_no, to: :commodity, prefix: true)
+
+      def validate_commodity_status
+        return unless commodity
+
+        errors.add(:commodity, 'should be approved first.') unless commodity.approved
+      end
+
+      def validate_quantity
+        return unless commodity && quantity
+
+        requested = RhnRequest.where(commodity: commodity).sum(:quantity)
+        remaining = commodity.quantity - requested
+
+        remaining += quantity_was if quantity_was
+        errors.add(:quantity, "exceeds commodity quantity. Maximum allowed is #{remaining}") if quantity > remaining
+      end
+
+      def approve
+        self.status = APPROVED
+        save!
+      end
     end
   end
 end

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

@@ -2,9 +2,6 @@ module Cats
   module Core
     class DispatchService
       def create_receipt_authorization(reference_no, allocation_item, quantity, remark, user)
-        status = allocation_item.allocation.allocation_status
-        raise(StandardError, 'Allocation not approved.') unless status == Cats::Core::Allocation::APPROVED
-
         transporter = Cats::Core::Transporter.find_by(code: 'SUP-TRANS')
         raise(StandardError, 'Supplier transporter does not exist.') unless transporter
 
@@ -16,27 +13,30 @@ module Cats
 
         raise(StandardError, 'Commodity not found in supplier store.') unless stack
 
-        dispatch = Cats::Core::Dispatch.create!(
-          reference_no: reference_no,
-          allocation_item: allocation_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
-        )
+        dispatch = nil
+        ApplicationRecord.transaction do
+          dispatch = Cats::Core::Dispatch.create!(
+            reference_no: reference_no,
+            allocation_item: allocation_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
-        )
+          # 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
 
@@ -87,52 +87,12 @@ module Cats
         dispatches
       end
 
-      def approve(dispatch)
-        unless dispatch.dispatch_status == Cats::Core::Dispatch::DRAFT
-          raise(StandardError, 'Dispatch has to be in draft state.')
-        end
-
-        transactions = Cats::Core::DispatchTransaction.where(destination: dispatch).count
-        raise(StandardError, 'Dispatch has no transactions.') unless transactions.positive?
-
-        dispatch.dispatch_status = Cats::Core::Dispatch::APPROVED
-        dispatch.save
-        dispatch
-      end
-
       def start(dispatch)
-        unless dispatch.dispatch_status == Cats::Core::Dispatch::APPROVED
-          raise(StandardError, 'Dispatch has to be approved first.')
-        end
-
-        dispatch.dispatch_status = Cats::Core::Dispatch::STARTED
-        dispatch.save
-        transactions = Cats::Core::DispatchTransaction.where(destination: dispatch)
-        transactions.each(&:commit)
+        dispatch.start
         send_notification(dispatch)
         dispatch
       end
 
-      def confirm(dispatch)
-        total = dispatch.receipts.sum(:quantity)
-
-        unless total == dispatch.quantity
-          raise(
-            StandardError,
-            "There is an amount of #{dispatch.quantity - total} in the dispatch which is unaccounted for."
-          )
-        end
-
-        Cats::Core::Dispatch.transaction do
-          dispatch.dispatch_status = Cats::Core::Dispatch::RECEIVED
-          dispatch.receipts.each { |r| r.status = Cats::Core::Receipt::CONFIRMED }
-          dispatch.save
-          dispatch.receipts.each(&:save!)
-        end
-
-        dispatch
-      end
-
       def send_notification(dispatch)
         notification_rule = Cats::Core::NotificationRule.find_by(code: 'dispatch')
         raise(StandardError, 'Notification rule not found for dispatch notification.') unless notification_rule

data/db/migrate/20211024063240_add_status_to_cats_core_rhn_requests.rb

@@ -0,0 +1,5 @@
+class AddStatusToCatsCoreRhnRequests < ActiveRecord::Migration[6.1]
+  def change
+    add_column :cats_core_rhn_requests, :status, :string, null: false, default: 'Draft'
+  end
+end

data/lib/cats/core/version.rb

@@ -1,5 +1,5 @@
 module Cats
   module Core
-    VERSION = '1.1.34'.freeze
+    VERSION = '1.1.38'.freeze
   end
 end

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

@@ -2,7 +2,7 @@ FactoryBot.define do
   factory :allocation_item, class: 'Cats::Core::AllocationItem' do
     allocation
     destination factory: :location
-    quantity { 100 }
+    quantity { 50 }
     from { Date.today }
     to { Date.today + 1.week }
   end

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

@@ -8,6 +8,6 @@ FactoryBot.define do
     best_use_before { Date.today + 2.month }
     volume_per_metric_ton { 10 }
     arrival_status { Cats::Core::Commodity::AT_SOURCE }
-    approved { false }
+    approved { true }
   end
 end

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

@@ -1,7 +1,12 @@
 FactoryBot.define do
   factory :dispatch, class: 'Cats::Core::Dispatch' do
     reference_no { FFaker::Name.name }
-    allocation_item
+    allocation_item do
+      allocation = create(:allocation, quantity: 100)
+      allocation_item = create(:allocation_item, allocation: allocation, quantity: 100)
+      allocation.approve
+      allocation_item
+    end
     transporter
     plate_no { FFaker::Name.name }
     driver_name { FFaker::Name.name }

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

@@ -1,6 +1,12 @@
 FactoryBot.define do
   factory :receipt, class: 'Cats::Core::Receipt' do
-    dispatch factory: :dispatch, dispatch_status: Cats::Core::Dispatch::STARTED
+    dispatch do
+      dispatch = create(:dispatch)
+      create(:dispatch_transaction, destination: dispatch, quantity: 50)
+      dispatch.approve
+      dispatch.start
+      dispatch
+    end
     quantity { 50 }
     commodity_status { Cats::Core::Commodity::GOOD }
     status { Cats::Core::Receipt::DRAFT }

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

@@ -5,5 +5,6 @@ FactoryBot.define do
     quantity { 100 }
     request_date { Date.today }
     requested_by { FFaker::Name.name }
+    status { Cats::Core::RhnRequest::DRAFT }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cats_core
 version: !ruby/object:Gem::Version
-  version: 1.1.34
+  version: 1.1.38
 platform: ruby
 authors:
 - Henock L.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-23 00:00:00.000000000 Z
+date: 2021-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -345,6 +345,7 @@ files:
 - 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
+- db/migrate/20211024063240_add_status_to_cats_core_rhn_requests.rb
 - lib/cats/core.rb
 - lib/cats/core/engine.rb
 - lib/cats/core/version.rb