cats_core 1.0.48 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0cb918631b3c8651aca92abc3209f968ce85fbb0e6408332ae5683b95130333
-  data.tar.gz: 3dca9a7897114e6bf7830951190ac504eaceb03e2f9bf1e3f7de1c5bd1158a5a
+  metadata.gz: e1410fa75e3f9e4eb96e4c9df8cbd6bb358bb56e4cce6ef42b095aff3b6331b1
+  data.tar.gz: c1529759ffa5ba650bd31df10ae302943afc14e876fff0710a35144cf0841981
 SHA512:
-  metadata.gz: a8d658d04da98b1e5607be0843fdfde3663d7ea089b56b9fd7f073420ffa00715613426233c066ca1a92f503bfd8bbc8b9a91663f633ddb93b3e779d1546496a
-  data.tar.gz: 4aa0772c1ca60ec644476785dc96b3fe7639fcb77e2a97d76e6d757f0a44c6a8f8beb6738edd15361e4edeb41c6559f2ae9f6186bd20e601358fcf1cf1092ab9
+  metadata.gz: 9b31f50e3f08e9a65c1da38520f3afef988613654e5250607e48761274951d3be4975e6b47c704c65ad6211d03081ab1c60b3f6ae1eea6fae191d498bd021110
+  data.tar.gz: 4046501c4c360769d9bc23628f4e067b8c7b55d95f898d57fda4f202f75ddc73fa5d5a60e5f163cf37ab340024b12a28065bb80f8be9eb5f5fb64d81151e8863

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

@@ -0,0 +1,13 @@
+module Cats
+  module Core
+    class DispatchTransactionsController < 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/dispatches_controller.rb

@@ -0,0 +1,75 @@
+module Cats
+  module Core
+    class DispatchesController < ApplicationController
+      include Common
+
+      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])
+        render json: { success: true, data: serialize(dispatches) }
+      end
+
+      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
+        else
+          render json: { success: false, error: dispatch.errors.full_messages[0] }, status: :unprocessable_entity
+        end
+      end
+
+      def create_receipt_authorization
+        allocation_item = Cats::Core::AllocationItem.find(params[:id])
+        dispatch = @service.create_receipt_authorization(
+          params[:reference_no], allocation_item, params[:quantity], params[:remark], current_user
+        )
+        render json: { success: true, data: serialize(dispatch) }
+      end
+
+      def approve
+        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 = @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)
+        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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+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
+
+      private
+
+      def model_params
+        params.require(:payload).permit(:dispatch_id, :quantity, :commodity_status, :status, :remark, :prepared_by_id)
+      end
+    end
+  end
+end

data/app/controllers/concerns/cats/core/common.rb

@@ -0,0 +1,55 @@
+module Cats
+  module Core
+    module Common
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :set_clazz
+        before_action :set_object, only: %i[show update]
+      end
+
+      def index
+        data = serialize(@clazz.all)
+        render json: { success: true, data: data }
+      end
+
+      def show
+        render json: { success: true, data: serialize(@obj) }
+      end
+
+      def create
+        obj = @clazz.new(model_params)
+        if obj.save
+          render json: { success: true, data: serialize(obj) }, status: :created
+        else
+          render json: { success: false, error: obj.errors.full_messages[0] }, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        if @obj.update(model_params)
+          render json: { success: true, data: serialize(@obj) }
+        else
+          render json: { success: false, error: @obj.errors.full_messages[0] }, status: :unprocessable_entity
+        end
+      end
+
+      private
+
+      def serialize(data)
+        ActiveModelSerializers::SerializableResource.new(data)
+      end
+
+      def set_clazz
+        @clazz = "Cats::Core::#{controller_name.classify}".constantize
+      end
+
+      def set_object
+        @obj = @clazz.find(params[:id])
+      end
+
+      # This class should be overridden by respective child controllers
+      def model_params; 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,9 +3,8 @@ 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
+      RECEIPT_STATUSES = [DRAFT, CONFIRMED].freeze
 
       belongs_to :dispatch
       belongs_to :prepared_by, class_name: 'Cats::Core::User'
@@ -14,6 +13,28 @@ module Cats
       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
+
+        return if dispatch.dispatch_status == Cats::Core::Dispatch::STARTED
+
+        errors.add(:dispatch, 'Dispatch should be in "Started" state.')
+      end
+
+      def validate_total_quantity
+        return unless dispatch && quantity
+
+        received = Cats::Core::Receipt.where(dispatch: dispatch).sum(:quantity)
+        remaining = dispatch.quantity - received
+        return if quantity <= remaining
+
+        errors.add(:quantity, "Total receipt quantity is higher than dispatch quantity (Max = #{remaining}).")
+      end
     end
   end
 end

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

@@ -2,6 +2,7 @@ module Cats
   module Core
     class Transaction < ApplicationRecord
       self.abstract_class = true
+      after_initialize :set_status
 
       # Transaction statuses
       DRAFT = 'Draft'.freeze
@@ -25,8 +26,16 @@ module Cats
           destination.quantity += quantity
           source.save
           destination.save
+          self.status = COMMITTED
+          save
         end
       end
+
+      def set_status
+        return unless new_record?
+
+        self.status = DRAFT
+      end
     end
   end
 end

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

@@ -0,0 +1,8 @@
+class DispatchSerializer < ActiveModel::Serializer
+  attributes :id, :reference_no, :allocation_item_id, :transporter_id, :transporter_name, :plate_no, :driver_name,
+             :driver_phone, :quantity, :remark, :prepared_by_id, :prepared_by_email, :dispatch_status, :destination
+
+  def destination
+    object.allocation_item.destination.name
+  end
+end

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

@@ -0,0 +1,4 @@
+class DispatchTransactionSerializer < ActiveModel::Serializer
+  attributes :id, :source_id, :source_code, :destination_id, :destination_reference_no, :quantity, :transaction_date,
+             :status
+end

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/services/cats/core/dispatch_service.rb

@@ -0,0 +1,136 @@
+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
+
+        store = Cats::Core::Store.find_by(code: 'SUP-STORE')
+        raise(StandardError, 'Supplier store does not exist.') unless store
+
+        commodity = allocation_item.allocation.commodity
+        stack = store.stacks.find_by(commodity: commodity)
+
+        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
+        )
+
+        # Create a dispatch transaction
+        Cats::Core::DispatchTransaction.create!(
+          source: stack,
+          destination: dispatch,
+          transaction_date: Date.today,
+          quantity: quantity,
+          status: Cats::Core::Transaction::DRAFT
+        )
+        dispatch
+      end
+
+      def search(user)
+        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: Cats::Core::Dispatch::STARTED
+                                           ).or(
+                                             Cats::Core::Dispatch.joins(:allocation_item)
+                                                                 .where(
+                                                                   allocation_item: { destination: warehouse },
+                                                                   dispatch_status: Cats::Core::Dispatch::STARTED
+                                                                 )
+                                           )
+        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: Cats::Core::Dispatch::STARTED
+                                           ).or(
+                                             Cats::Core::Dispatch.joins(:allocation_item)
+                                                                 .where(
+                                                                   allocation_item: { destination: warehouse },
+                                                                   dispatch_status: Cats::Core::Dispatch::STARTED
+                                                                 )
+                                           )
+        elsif details['hub']
+          hub = Cats::Core::Location.find(details['hub'])
+          dispatches = Cats::Core::Dispatch.joins(:allocation_item)
+                                           .where(
+                                             allocation_item: { destination: hub },
+                                             dispatch_status: Cats::Core::Dispatch::STARTED
+                                           )
+        end
+        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
+      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/space_service.rb

@@ -8,7 +8,9 @@ module Cats
       def available_space(id, level)
         case level
         when HUB
-          warehouse_ids = Cats::Core::Location.find(id).children.map(&:id)
+          hub = Cats::Core::Location.find(id)
+          warehouses = hub.children
+          warehouse_ids = warehouses.map(&:id)
           stores = Cats::Core::Store.joins(:warehouse)
                                     .where(
                                       cats_core_locations: {
@@ -19,19 +21,48 @@ module Cats
           wh_details = []
           stores.each do |key, value|
             total_space = value.inject(0) { |sum, val| sum + val.available_space }
-            details = value.map { |val| { store_id: val.id, total_space: val.available_space } }
-            wh_details << { warehouse_id: key, total_space: total_space, details: details }
+            details = value.map do |val|
+              { store_id: val.id, code: val.code, name: val.name, total_space: val.available_space }
+            end
+            warehouse = warehouses.find(key)
+            wh_details << {
+              warehouse_id: key,
+              code: warehouse.code,
+              name: warehouse.name,
+              total_space: total_space,
+              details: details
+            }
           end
           hub_space = wh_details.inject(0) { |sum, val| sum + val[:total_space] }
-          space = { hub_id: id, total_space: hub_space, details: wh_details }
+          space = {
+            hub_id: id,
+            code: hub.code,
+            name: hub.name,
+            total_space: hub_space,
+            details: wh_details
+          }
         when WAREHOUSE
+          warehouse = Cats::Core::Location.find(id)
           stores = Cats::Core::Store.where(warehouse_id: id)
-          details = stores.map { |store| { store_id: store.id, total_space: store.available_space } }
+          details = stores.map do |store|
+            { store_id: store.id, code: store.code, name: store.name, total_space: store.available_space }
+          end
           total_space = stores.inject(0) { |sum, val| sum + val.available_space }
-          space = { warehouse_id: id, total_space: total_space, details: details }
+          space = {
+            warehouse_id: id,
+            code: warehouse.code,
+            name: warehouse.name,
+            total_space: total_space,
+            details: details
+          }
         when STORE
           store = Cats::Core::Store.find(id)
-          space = { store_id: store.id, total_space: store.available_space }
+          space = {
+            store_id: store.id,
+            code: store.code,
+            name: store.name,
+            total_space: store.available_space
+          }
         end
         space
       end

data/config/routes.rb

@@ -33,11 +33,11 @@ Cats::Core::Engine.routes.draw do
       to: 'spaces#available_space',
       as: :hub_space, 
       defaults: { level: Cats::Core::SpaceService::HUB }
-  get '/warehousess/:id/space',
+  get '/warehouses/:id/space',
       to: 'spaces#available_space',
       as: :warehouse_space,
       defaults: { level: Cats::Core::SpaceService::WAREHOUSE }
-  get '/store/:id/space',
+  get '/stores/:id/space',
       to: 'spaces#available_space',
       as: :store_space,
       defaults: { level: Cats::Core::SpaceService::STORE }
@@ -49,4 +49,22 @@ Cats::Core::Engine.routes.draw do
   end
   resources :currencies, except: %i[destroy]
   resources :unit_of_measures, except: %i[destroy]
+
+  get '/allocation_items/:id/dispatches', controller: :dispatches, action: :index, as: :dispatches_allocation_item
+  post '/allocation_items/:id/receipt_authorizaton',
+       controller: :dispatches,
+       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]
 end

data/lib/cats/core/version.rb

@@ -1,5 +1,5 @@
 module Cats
   module Core
-    VERSION = '1.0.48'.freeze
+    VERSION = '1.1.1'.freeze
   end
 end

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

@@ -1,6 +1,6 @@
 FactoryBot.define do
   factory :receipt, class: 'Cats::Core::Receipt' do
-    dispatch
+    dispatch factory: :dispatch, dispatch_status: Cats::Core::Dispatch::STARTED
     quantity { 1.5 }
     commodity_status { Cats::Core::Commodity::GOOD }
     status { Cats::Core::Receipt::DRAFT }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cats_core
 version: !ruby/object:Gem::Version
-  version: 1.0.48
+  version: 1.1.1
 platform: ruby
 authors:
 - Henock L.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-22 00:00:00.000000000 Z
+date: 2021-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -220,13 +220,17 @@ files:
 - app/controllers/cats/core/application_controller.rb
 - app/controllers/cats/core/commodity_categories_controller.rb
 - app/controllers/cats/core/currencies_controller.rb
+- app/controllers/cats/core/dispatch_transactions_controller.rb
+- app/controllers/cats/core/dispatches_controller.rb
 - 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/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
 - app/controllers/cats/core/users_controller.rb
+- app/controllers/concerns/cats/core/common.rb
 - app/jobs/cats/core/application_job.rb
 - app/models/cats/core/allocation.rb
 - app/models/cats/core/allocation_item.rb
@@ -269,9 +273,13 @@ files:
 - app/notifications/cats/core/simple_notification.rb
 - app/serializers/cats/core/commodity_category_serializer.rb
 - app/serializers/cats/core/currency_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/receipt_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/space_service.rb