cats_core 1.1.0 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebf6bb336bcf7b1fa89d734c18444e8f41b586c480a24b675fb62d5a8e3d5528
-  data.tar.gz: 6a5adfade3042c981cc482f336393cd51265a636e56b2ae91b5f4c1d8193840a
+  metadata.gz: 63d1bc4e2e97985bc79c49007a2d826b43caec3b8fc31eca51fa4f588d22e10f
+  data.tar.gz: d4d08836b88121d75bd29fb711975726285b9ab5f7b64285ed48349cff51e2e3
 SHA512:
-  metadata.gz: 5e3075ca71388f92b600ebfeb4d951e003b200987683a5de62d7138107d14efbd6c94a11425c1770e650ecf5facdcefd8ca90de71bb97d5b1685a9d787ef7ead
-  data.tar.gz: ecd7c5c357ea9e8a05c06523cd821a8c10fd21611e5cbc27390fefc8cec5aa54ea840175eb5c8419f484654bdb5a7918d2d551c36de242599e9b41dfa32377d8
+  metadata.gz: 6bc9fdab7012e63bcda95512f54f0fe8586c225a8eec25c88dcc3ed6b0634aa21a6a62ba5e6091f21b718f10d9df93eeabdf0a88a62a78891f244dc2c14d3bac
+  data.tar.gz: 9ced66786a2d6303d5ea944366cf9357ff9d3a9ab8e4406d2a6c490d8969e0c6431b2265e321a965a2ab10c503bc51e4cbdd40766581f8af6ccf844405f58527

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

@@ -3,7 +3,8 @@ module Cats
     class DispatchesController < ApplicationController
       include Common
 
-      before_action :set_service, only: %i[create_receipt_authorization approve start]
+      before_action :set_service, only: %i[create_receipt_authorization approve start search confirm]
+      before_action :set_dispatch, only: %i[approve start confirm]
 
       def index
         dispatches = Cats::Core::Dispatch.where(allocation_item_id: params[:id])
@@ -12,6 +13,7 @@ module Cats
 
       def create
         dispatch = Cats::Core::Dispatch.new(model_params)
+        dispatch.dispatch_status = Cats::Core::Dispatch::DRAFT
         dispatch.prepared_by = current_user
         if dispatch.save
           render json: { success: true, data: serialize(dispatch) }, status: :created
@@ -29,30 +31,44 @@ module Cats
       end
 
       def approve
-        dispatch = Cats::Core::Dispatch.find(params[:id])
-        dispatch = @service.approve(dispatch)
+        dispatch = @service.approve(@dispatch)
         render json: { success: true, data: serialize(dispatch) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
       end
 
       def start
-        dispatch = Cats::Core::Dispatch.find(params[:id])
-        dispatch = @service.start(dispatch)
+        dispatch = @service.start(@dispatch)
         render json: { success: true, data: serialize(dispatch) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
       end
 
+      def confirm
+        dispatch = @service.confirm(@dispatch)
+        render json: { success: true, data: serialize(dispatch) }
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
+      end
+
+      def search
+        data = @service.search(current_user, params[:status])
+        render json: { success: true, data: serialize(data) }
+      end
+
       private
 
       def set_service
         @service = DispatchService.new
       end
 
+      def set_dispatch
+        @dispatch = Cats::Core::Dispatch.find(params[:id])
+      end
+
       def model_params
         params.require(:payload).permit(:reference_no, :allocation_item_id, :transporter_id, :plate_no, :driver_name,
-                                        :driver_phone, :quantity, :remark, :dispatch_status)
+                                        :driver_phone, :quantity, :remark)
       end
     end
   end

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

@@ -1,50 +1,20 @@
 module Cats
   module Core
     class LocationsController < ApplicationController
-      before_action :set_location, only: %i[show update]
+      include Common
 
       def index
         locations = Cats::Core::Location.where(location_type: params[:location_type])
-        data = ActiveModelSerializers::SerializableResource.new(locations)
-        render json: { success: true, data: data }
-      end
-
-      def show
-        data = ActiveModelSerializers::SerializableResource.new(@location)
-        render json: { success: true, data: data }
+        render json: { success: true, data: serialize(locations) }
       end
 
       def children
         parent = Cats::Core::Location.find(params[:id])
-        data = ActiveModelSerializers::SerializableResource.new(parent.children)
-        render json: { success: true, data: data }
-      end
-
-      def create
-        obj = Cats::Core::Location.new(model_params)
-        if obj.save
-          data = ActiveModelSerializers::SerializableResource.new(obj)
-          render json: { success: true, data: data }, status: :created
-        else
-          render json: { success: false, error: obj.errors.full_messages[0] }, status: :unprocessable_entity
-        end
-      end
-
-      def update
-        if @location.update(model_params)
-          data = ActiveModelSerializers::SerializableResource.new(@location)
-          render json: { success: true, data: data }
-        else
-          render json: { success: false, error: @location.errors.full_messages[0] }, status: :unprocessable_entity
-        end
+        render json: { success: true, data: serialize(parent.children) }
       end
 
       private
 
-      def set_location
-        @location = Cats::Core::Location.find(params[:id])
-      end
-
       def model_params
         params.require(:payload).permit(:code, :name, :location_type, :description, :parent_id)
       end

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

@@ -0,0 +1,13 @@
+module Cats
+  module Core
+    class ReceiptTransactionsController < ApplicationController
+      include Common
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:source_id, :destination_id, :transaction_date, :quantity)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Cats
+  module Core
+    class ReceiptsController < ApplicationController
+      include Common
+
+      def index
+        receipts = Cats::Core::Receipt.where(dispatch_id: params[:id])
+        render json: { success: true, data: serialize(receipts) }
+      end
+
+      def start_stacking
+        receipt = Cats::Core::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 stack
+        receipt = Cats::Core::Receipt.find(params[:id])
+        service = ReceiptService.new
+        result = service.stack(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/dispatch.rb

@@ -13,6 +13,7 @@ module Cats
       belongs_to :prepared_by, class_name: 'Cats::Core::User'
       belongs_to :transporter
       belongs_to :allocation_item
+      has_many :receipts
 
       validates :reference_no, :plate_no, :driver_name, :driver_phone, :quantity, :commodity_status, presence: true
       validates :dispatch_status, presence: true, inclusion: { in: DISPATCH_STATUSES }

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

@@ -3,17 +3,48 @@ module Cats
     class Receipt < ApplicationRecord
       # Receipt status
       DRAFT = 'Draft'.freeze
-      ACCEPTED = 'Accepted'.freeze
-      DECLINED = 'Declined'.freeze
-      RECEIPT_STATUSES = [DRAFT, ACCEPTED, DECLINED].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, foreign_key: :source_id
 
       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)
+        diff = dispatch.quantity - received
+        if new_record?
+          return if quantity <= diff
+
+          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
+      end
     end
   end
 end

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

@@ -3,6 +3,8 @@ module Cats
     class ReceiptTransaction < Transaction
       belongs_to :source, class_name: 'Cats::Core::Receipt'
       belongs_to :destination, class_name: 'Cats::Core::Stack'
+
+      delegate(:code, to: :destination, prefix: true)
     end
   end
 end

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

@@ -12,12 +12,14 @@ module Cats
       validates :transaction_date, :quantity, :status, presence: true
       validates :quantity, numericality: { greater_than: 0 }
       validates :status, inclusion: { in: STATUSES }
-      validate :validate_quantity
+      validate :validate_quantity, unless: :skip_quantity_validation
 
       def validate_quantity
         return unless quantity.present? && source.present?
 
-        errors.add(:quantity, 'cannot be more than source quantity') if quantity > source.quantity
+        total = self.class.where(source: source).sum(:quantity)
+        diff = source.quantity - total
+        errors.add(:quantity, "total is higher than source quantity (Max = #{diff}).") if quantity > diff
       end
 
       def commit
@@ -27,10 +29,23 @@ module Cats
           source.save
           destination.save
           self.status = COMMITTED
-          save
+          save!
         end
       end
 
+      def skip_quantity_validation
+        # Quantity validation should be skipped if we are commiting transactions.
+        (
+          instance_of?(Cats::Core::DispatchTransaction) &&
+          destination &&
+          destination.dispatch_status == Cats::Core::Dispatch::STARTED
+        ) || (
+          instance_of?(Cats::Core::ReceiptTransaction) &&
+          source &&
+          source.status == Cats::Core::Receipt::STACKING
+        )
+      end
+
       def set_status
         return unless new_record?
 

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

@@ -0,0 +1,4 @@
+class ReceiptSerializer < ActiveModel::Serializer
+  attributes :id, :dispatch_id, :dispatch_reference_no, :commodity_status, :quantity, :status, :remark,
+             :prepared_by_id, :prepared_by_email
+end

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

@@ -0,0 +1,8 @@
+class ReceiptTransactionSerializer < ActiveModel::Serializer
+  attributes :id, :source_id, :dispatch_reference, :destination_id, :destination_code, :quantity, :transaction_date,
+             :status
+
+  def dispatch_reference
+    object.source.dispatch.reference_no
+  end
+end

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

@@ -40,6 +40,53 @@ module Cats
         dispatch
       end
 
+      def search(user, status)
+        details = user.details
+
+        unless details['stores'] || details['warehouse'] || details['hub']
+          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(:allocation_item)
+                                           .where(
+                                             allocation_item: { destination: hub },
+                                             dispatch_status: status
+                                           ).or(
+                                             Cats::Core::Dispatch.joins(:allocation_item)
+                                                                 .where(
+                                                                   allocation_item: { destination: warehouse },
+                                                                   dispatch_status: status
+                                                                 )
+                                           )
+        elsif details['warehouse']
+          warehouse = Cats::Core::Location.find(details['warehouse'])
+          hub = warehouse.parent
+          dispatches = Cats::Core::Dispatch.joins(:allocation_item)
+                                           .where(
+                                             allocation_item: { destination: hub },
+                                             dispatch_status: status
+                                           ).or(
+                                             Cats::Core::Dispatch.joins(:allocation_item)
+                                                                 .where(
+                                                                   allocation_item: { destination: warehouse },
+                                                                   dispatch_status: status
+                                                                 )
+                                           )
+        elsif details['hub']
+          hub = Cats::Core::Location.find(details['hub'])
+          dispatches = Cats::Core::Dispatch.joins(:allocation_item)
+                                           .where(
+                                             allocation_item: { destination: hub },
+                                             dispatch_status: status
+                                           )
+        end
+        dispatches
+      end
+
       def approve(dispatch)
         unless dispatch.dispatch_status == Cats::Core::Dispatch::DRAFT
           raise(StandardError, 'Dispatch has to be in draft state.')
@@ -64,6 +111,26 @@ module Cats
         transactions.each(&:commit)
         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
     end
   end
 end

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

@@ -0,0 +1,32 @@
+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 stack(receipt)
+        unless receipt.status == Cats::Core::Receipt::STACKING
+          raise(StandardError, 'Receipt should be in stacking state.')
+        end
+
+        receipt.status = Cats::Core::Receipt::STACKED
+        stacks = receipt.receipt_transactions.map(&:destination)
+        stacks.each { |stack| stack.stack_status = Cats::Core::Stack::ALLOCATED }
+
+        Cats::Core::Receipt.transaction do
+          receipt.receipt_transactions.each(&:commit)
+          stacks.each(&:save!)
+          receipt.save!
+        end
+        receipt
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -56,11 +56,21 @@ Cats::Core::Engine.routes.draw do
        action: :create_receipt_authorization,
        as: :receipt_authorization_allocation_item
 
+  get '/dispatches/search', controller: :dispatches, action: :search, as: :search_dispatches
   resources :dispatches, except: %i[index destroy] do
     member do
+      get 'receipts', controller: :receipts, action: :index
       post 'approve'
       post 'start'
+      post 'confirm'
     end
   end
   resources :dispatch_transactions, except: %i[new edit destroy]
+  resources :receipts, except: %i[index new edit destroy] do
+    member do
+      post 'start_stacking'
+      post 'stack'
+    end
+  end
+  resources :receipt_transactions, except: %i[new edit destroy]
 end

data/lib/cats/core/version.rb

@@ -1,5 +1,5 @@
 module Cats
   module Core
-    VERSION = '1.1.0'.freeze
+    VERSION = '1.1.4'.freeze
   end
 end

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

@@ -1,5 +1,5 @@
 FactoryBot.define do
-  factory :receipt_transaction do
+  factory :receipt_transaction, class: 'Cats::Core::ReceiptTransaction' do
     source factory: :receipt
     destination factory: :stack
     transaction_date { Date.today }

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

@@ -1,7 +1,7 @@
 FactoryBot.define do
   factory :receipt, class: 'Cats::Core::Receipt' do
-    dispatch
-    quantity { 1.5 }
+    dispatch factory: :dispatch, dispatch_status: Cats::Core::Dispatch::STARTED
+    quantity { 50 }
     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.1.0
+  version: 1.1.4
 platform: ruby
 authors:
 - Henock L.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-23 00:00:00.000000000 Z
+date: 2021-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -225,6 +225,8 @@ files:
 - app/controllers/cats/core/locations_controller.rb
 - app/controllers/cats/core/menus_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/spaces_controller.rb
 - app/controllers/cats/core/unit_of_measures_controller.rb
@@ -275,11 +277,14 @@ files:
 - 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/receipt_serializer.rb
+- app/serializers/cats/core/receipt_transaction_serializer.rb
 - app/serializers/cats/core/role_menu_serializer.rb
 - app/serializers/cats/core/unit_of_measure_serializer.rb
 - 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/space_service.rb
 - app/services/cats/core/token_auth_service.rb
 - config/routes.rb