cats_core 1.4.6 → 1.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 564c9a64ea8c7ddbcdd6afcd9b8270091f9f47484dc16e51c33eae196c584410
-  data.tar.gz: 29e5f1548a143c4bddfb74ac1984f63ce29b442ce86067efef3bfe150558f339
+  metadata.gz: a1eacca23e0a10e3a707dcc45f51e2c44013fccb7a35182f3d7476c95d0bcad8
+  data.tar.gz: bcbcaf4bda959f028521528e8e7c979bca422037c9e4abb913449f831cadc73b
 SHA512:
-  metadata.gz: 74a80138ca25fe94455f36b1b4bfaa5b8e5522fc0a6a6beea072358e82b233e1a19d2d08a981f551a628d0d65c18e8a180ff2777f4ef7764dbbb9b3f759b5cc0
-  data.tar.gz: d029c881f9b027f87bcdc73f5ff211e700b9e63bc9a71cc3fa5c8f610cab67f6d3787d4e9613b95778924318abd35b93d8cc98c8293faab2eb896402ebd580ba
+  metadata.gz: b34d8901501515edaa28a7aea773ccea4156f079124be80200ab77673f22357e3f1e7891e667244ec8ffcc11a6310a5a575a36ab549468dc292fc7ad5bc868b5
+  data.tar.gz: bc9c7ea903b2cfaf05db1819391c0c5b2d2999498b3ee488263c240bc2971a67fe85b24911afd1432ef7aef81bc6b6f473cfc0ba34516839a93cc69b06571ad1

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

@@ -4,7 +4,7 @@ module Cats
       skip_before_action :authenticate, only: [:login]
 
       def login
-        user = Cats::Core::User.find_by(email: auth_params[:email])
+        user = User.find_by(email: auth_params[:email])
         if user
           if user.authenticate(auth_params[:password])
             roles = user.roles.map(&:name)
@@ -18,7 +18,7 @@ module Cats
               id: user.id, email: user.email, first_name: user.first_name, last_name: user.last_name, roles: roles,
               details: user.details
             }
-            jwt = Cats::Core::TokenAuthService.issue(payload)
+            jwt = TokenAuthService.issue(payload)
             render json: { token: jwt, user: payload }
           else
             render json: { error: 'Invalid password.' }, status: 400

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

@@ -6,7 +6,7 @@ module Cats
       def current_user
         return if token.nil?
 
-        user = Cats::Core::User.find(auth['id'])
+        user = User.find(auth['id'])
         @current_user ||= user
       end
 
@@ -27,7 +27,7 @@ module Cats
       end
 
       def auth
-        Cats::Core::TokenAuthService.decode(token)
+        TokenAuthService.decode(token)
       end
     end
   end

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

@@ -4,28 +4,15 @@ module Cats
       include Common
 
       def approve
-        commodity = Cats::Core::Commodity.find(params[:id])
+        commodity = Commodity.find(params[:id])
         result = commodity.approve
         render json: { success: result, data: serialize(commodity) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
       end
 
-      def update
-        if @obj.status == Cats::Core::Commodity::APPROVED
-          render json: { success: false, error: 'An approved record cannot be edited.' }
-          return
-        end
-
-        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
-
       def filter
-        query = Cats::Core::Commodity.ransack(params[:q])
+        query = Commodity.ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 

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

@@ -1,62 +1,31 @@
 module Cats
   module Core
     class CommodityCategoriesController < ApplicationController
-      before_action :set_commodity_category, only: %i[show update]
+      include Common
 
       def index
-        commodity_categories = Cats::Core::CommodityCategory.all.reject(&:has_children?)
-        data = ActiveModelSerializers::SerializableResource.new(commodity_categories)
-        render json: { success: true, data: data }
+        super do
+          CommodityCategory.all.reject(&:has_children?)
+        end
       end
 
       def all
-        data = Cats::Core::CommodityCategory.all
+        data = CommodityCategory.all
         render json: { success: true, data: data }
       end
 
       def root
-        data = Cats::Core::CommodityCategory.roots
+        data = CommodityCategory.roots
         render json: { success: true, data: serialize(data) }
       end
 
-      def show
-        data = ActiveModelSerializers::SerializableResource.new(@commodity_category)
-        render json: { success: true, data: data }
-      end
-
       def children
-        parent = Cats::Core::CommodityCategory.find(params[:id])
-        data = ActiveModelSerializers::SerializableResource.new(parent.children)
-        render json: { success: true, data: data }
-      end
-
-      def create
-        obj = Cats::Core::CommodityCategory.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 @commodity_category.update(model_params)
-          data = ActiveModelSerializers::SerializableResource.new(@commodity_category)
-          render json: { success: true, data: data }
-        else
-          render json: {
-            success: false, error: @commodity_category.errors.full_messages[0]
-          }, status: :unprocessable_entity
-        end
+        parent = CommodityCategory.find(params[:id])
+        render json: { success: true, data: serialize(parent.children) }
       end
 
       private
 
-      def set_commodity_category
-        @commodity_category = Cats::Core::CommodityCategory.find(params[:id])
-      end
-
       def model_params
         params.require('payload').permit(:code, :name, :description, :parent_id)
       end

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

@@ -4,12 +4,13 @@ module Cats
       include Common
 
       def index
-        items = Cats::Core::DispatchPlanItem.where(dispatch_plan_id: params[:id])
-        render json: { success: true, data: serialize(items) }
+        super do
+          DispatchPlanItem.where(dispatch_plan_id: params[:id])
+        end
       end
 
       def filter
-        query = Cats::Core::DispatchPlanItem.ransack(params[:q])
+        query = DispatchPlanItem.ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 

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

@@ -4,12 +4,12 @@ module Cats
       include Common
 
       def plans_for_user
-        plans = Cats::Core::DispatchPlan.where(prepared_by: current_user)
+        plans = DispatchPlan.where(prepared_by: current_user)
         render json: { success: true, data: serialize(plans) }
       end
 
       def filter
-        query = Cats::Core::DispatchPlan.ransack(params[:q])
+        query = DispatchPlan.ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 
@@ -23,7 +23,7 @@ module Cats
 
       def approve
         service = DispatchPlanService.new
-        plan = Cats::Core::DispatchPlan.find(params[:id])
+        plan = DispatchPlan.find(params[:id])
         plan = service.approve(plan)
         render json: { success: true, data: serialize(plan) }
       rescue StandardError => e

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

@@ -4,8 +4,9 @@ module Cats
       include Common
 
       def index
-        transactions = Cats::Core::DispatchTransaction.where(dispatch_id: params[:id])
-        render json: { success: true, data: serialize(transactions) }
+        super do
+          DispatchTransaction.where(dispatch_id: params[:id])
+        end
       end
 
       # This end-point is used to create upstream dispatch transactions.

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

@@ -4,41 +4,41 @@ module Cats
       include Common
 
       before_action :set_service, only: %i[create_receipt_authorization approve start search confirm]
-      before_action :set_dispatch, only: %i[approve start confirm commodity]
 
       def index
-        dispatches = Cats::Core::Dispatch.where(dispatch_plan_item_id: params[:id])
-        render json: { success: true, data: serialize(dispatches) }
+        super do
+          Dispatch.where(dispatch_plan_item_id: params[:id])
+        end
       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
+        super do
+          dispatch = Dispatch.new(model_params)
+          dispatch.dispatch_status = Dispatch::DRAFT
+          dispatch.prepared_by = current_user
+          dispatch
         end
       end
 
       def approve
-        @dispatch.approve
-        render json: { success: true, data: serialize(@dispatch) }
+        dispatch = set_object
+        dispatch.approve
+        render json: { success: true, data: serialize(dispatch) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
       end
 
       def start
-        dispatch = @service.start(@dispatch)
+        dispatch = @service.start(set_object)
         render json: { success: true, data: serialize(dispatch) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
       end
 
       def confirm
-        @dispatch.confirm
-        render json: { success: true, data: serialize(@dispatch) }
+        dispatch = set_object
+        dispatch.confirm
+        render json: { success: true, data: serialize(dispatch) }
       rescue StandardError => e
         render json: { success: false, error: e.message }
       end
@@ -49,7 +49,7 @@ module Cats
       end
 
       def commodity
-        data = @dispatch.dispatch_plan_item.commodity
+        data = set_object.dispatch_plan_item.commodity
         render json: { success: true, data: serialize(data) }
       end
 
@@ -59,10 +59,6 @@ module Cats
         @service = DispatchService.new
       end
 
-      def set_dispatch
-        @dispatch = Cats::Core::Dispatch.find(params[:id])
-      end
-
       def model_params
         params.require(:payload).permit(:reference_no, :dispatch_plan_item_id, :transporter_id, :plate_no,
                                         :driver_name, :driver_phone, :quantity, :remark)

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

@@ -4,17 +4,18 @@ module Cats
       include Common
 
       def index
-        locations = Cats::Core::Location.where(location_type: params[:location_type])
-        render json: { success: true, data: serialize(locations) }
+        super do
+          Location.where(location_type: params[:location_type])
+        end
       end
 
       def children
-        parent = Cats::Core::Location.find(params[:id])
+        parent = Location.find(params[:id])
         render json: { success: true, data: serialize(parent.children) }
       end
 
       def filter
-        query = Cats::Core::Location.ransack(params[:q])
+        query = Location.ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 

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

@@ -4,8 +4,9 @@ module Cats
       include Common
 
       def index
-        data = LostCommodity.where(dispatch_id: params[:id])
-        render json: { success: true, data: serialize(data) }
+        super do
+          LostCommodity.where(dispatch_id: params[:id])
+        end
       end
 
       def model_params

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

@@ -6,17 +6,18 @@ module Cats
       before_action :set_service, only: %i[generate remove_items generate_monthly_needs]
 
       def index
-        plans = Cats::Core::MonthlyPlan.where(plan: params[:id])
-        render json: { success: true, data: serialize(plans) }
+        super do
+          MonthlyPlan.where(plan: params[:id])
+        end
       end
 
       def filter
-        query = Cats::Core::MonthlyPlan.ransack(params[:q])
+        query = MonthlyPlan.ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 
       def approve
-        plan = Cats::Core::MonthlyPlan.find(params[:id])
+        plan = MonthlyPlan.find(params[:id])
         plan.approve
         render json: { success: true, data: serialize(plan) }
       rescue StandardError => e

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

@@ -2,6 +2,7 @@ module Cats
   module Core
     class NotificationsController < ApplicationController
       before_action :set_notification, only: %i[mark_as_read mark_as_unread]
+
       def index
         data = Notification.messages(current_user.notifications.newest_first)
         render json: { success: true, data: data }

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

@@ -4,28 +4,26 @@ module Cats
       include Common
 
       def index
-        transactions = Cats::Core::ReceiptTransaction.where(receipt_id: params[:id])
-        render json: { success: true, data: serialize(transactions) }
+        super do
+          ReceiptTransaction.where(receipt_id: params[:id])
+        end
       end
 
       def create
-        p = model_params
-
-        # Look for a transaction with the same destination as incoming
-        transaction = Cats::Core::ReceiptTransaction.find_by(
-          receipt_id: p[:receipt_id],
-          destination_id: p[:destination_id]
-        )
-        if transaction
-          transaction.quantity += p[:quantity]
-        else
-          transaction = Cats::Core::ReceiptTransaction.new(p)
-        end
+        super do
+          p = model_params
 
-        if transaction.save
-          render json: { success: true, data: serialize(transaction) }, status: :created
-        else
-          render json: { success: false, error: transaction.errors.full_messages[0] }, status: :unprocessable_entity
+          # 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
         end
       end
 

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

@@ -4,25 +4,21 @@ module Cats
       include Common
 
       def index
-        receipts = Cats::Core::Receipt.where(dispatch_id: params[:id])
-        render json: { success: true, data: serialize(receipts) }
+        super do
+          Receipt.where(dispatch_id: params[:id])
+        end
       end
 
       def create
-        service = ReceiptService.new
-        receipt = service.init(model_params)
-
-        if receipt.save
-          render json: { success: true, data: serialize(receipt) }
-        else
-          render json: { success: false, error: receipt.errors.full_messages[0] }, status: :unprocessable_entity
+        super do
+          service = ReceiptService.new
+          receipt = service.init(model_params)
+          receipt
         end
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
       end
 
       def start_stacking
-        receipt = Cats::Core::Receipt.find(params[:id])
+        receipt = Receipt.find(params[:id])
         service = ReceiptService.new
         result = service.start_stacking(receipt)
         render json: { success: true, data: serialize(result) }
@@ -31,7 +27,7 @@ module Cats
       end
 
       def finish_stacking
-        receipt = Cats::Core::Receipt.find(params[:id])
+        receipt = Receipt.find(params[:id])
         service = ReceiptService.new
         result = service.finish_stacking(receipt)
         render json: { success: true, data: serialize(result) }

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

@@ -6,21 +6,21 @@ module Cats
       before_action :set_role, only: [:users]
 
       def index
-        roles = Cats::Core::Role.joins(:application_module)
-                                .where(cats_core_application_modules: { prefix: params[:prefix] })
-        render json: { success: true, data: serialize(roles) }
+        super do
+          Role.joins(:application_module)
+              .where(cats_core_application_modules: { prefix: params[:prefix] })
+        end
       end
 
       def unassigned_roles
-        user = Cats::Core::User.find(params[:id])
-        roles = Cats::Core::Role.where(application_module_id: user.application_module_id)
+        user = User.find(params[:id])
+        roles = Role.where(application_module_id: user.application_module_id)
         unassigned = roles - user.roles
         render json: { success: true, data: serialize(unassigned) }
       end
 
       def users
-        data = ActiveModelSerializers::SerializableResource.new(@role.users)
-        render json: { success: true, data: data }
+        render json: { success: true, data: serialize(@role.users) }
       end
 
       private

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

@@ -4,7 +4,7 @@ module Cats
       include Common
 
       def filter
-        query = Cats::Core::Route.ransack(params[:q])
+        query = Route.ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 

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

@@ -4,8 +4,9 @@ module Cats
       include Common
 
       def index
-        stacks = Stack.where(store_id: params[:id])
-        render json: { success: true, data: serialize(stacks) }
+        super do
+          Stack.where(store_id: params[:id])
+        end
       end
 
       def filter

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

@@ -1,10 +1,10 @@
 module Cats
   module Core
     class TransportersController < ApplicationController
-      include Cats::Core::Common
+      include Common
 
       def filter
-        query = Cats::Core::Transporter.ransack(params[:q])
+        query = Transporter.ransack(params[:q])
         render json: { success: true, data: serialize(query.result) }
       end
 

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

@@ -1,46 +1,10 @@
 module Cats
   module Core
     class UnitOfMeasuresController < ApplicationController
-      before_action :set_unit_of_measure, only: %i[show update]
-
-      def index
-        data = ActiveModelSerializers::SerializableResource.new(Cats::Core::UnitOfMeasure.all)
-        render json: { success: true, data: data }
-      end
-
-      def show
-        data = ActiveModelSerializers::SerializableResource.new(@unit_of_measure)
-        render json: { success: true, data: data }
-      end
-
-      def create
-        obj = Cats::Core::UnitOfMeasure.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 @unit_of_measure.update(model_params)
-          data = ActiveModelSerializers::SerializableResource.new(@unit_of_measure)
-          render json: { success: true, data: data }
-        else
-          render json: {
-            success: false,
-            error: @unit_of_measure.errors.full_messages[0]
-          }, status: :unprocessable_entity
-        end
-      end
+      include Common
 
       private
 
-      def set_unit_of_measure
-        @unit_of_measure = Cats::Core::UnitOfMeasure.find(params[:id])
-      end
-
       def model_params
         params.require(:payload).permit(:abbreviation, :name, :unit_type)
       end

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

@@ -3,95 +3,84 @@ module Cats
     class UsersController < ApplicationController
       include Common
 
-      before_action :set_user, only: %i[update roles assign_role revoke_role stores warehouse hub]
-
       def index
-        users = Cats::Core::User.joins(:application_module)
-                                .where(cats_core_application_modules: { prefix: params[:prefix] })
-        render json: { success: true, data: serialize(users) }
+        super do
+          User.joins(:application_module).where(cats_core_application_modules: { prefix: params[:prefix] })
+        end
       end
 
       def create
-        prefix = model_params[:application_prefix]
-        application_module = Cats::Core::ApplicationModule.find_by(prefix: prefix)
+        super do
+          prefix = model_params[:application_prefix]
+          application_module = ApplicationModule.find_by(prefix: prefix)
 
-        obj = Cats::Core::User.new(model_params.except(:application_prefix))
-        obj.application_module = application_module
-        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
+          obj = User.new(model_params.except(:application_prefix))
+          obj.application_module = application_module
+          obj
         end
       end
 
       def update
+        user = set_object
         if model_params[:application_prefix]
           prefix = model_params[:application_prefix]
-          application_module = Cats::Core::ApplicationModule.find_by(prefix: prefix)
-          @user.assign_attributes(model_params.except(:application_prefix))
-          @user.application_module = application_module
+          application_module = ApplicationModule.find_by(prefix: prefix)
+          user.assign_attributes(model_params.except(:application_prefix))
+          user.application_module = application_module
         else
-          @user.assign_attributes(model_params)
+          user.assign_attributes(model_params)
         end
 
-        if @user.save
-          render json: { success: true, data: serialize(@user) }
+        if user.save
+          render json: { success: true, data: serialize(user) }
         else
-          render json: { success: false, error: @user.errors.full_messages[0] }, status: :unprocessable_entity
+          render json: { success: false, error: user.errors.full_messages[0] }, status: :unprocessable_entity
         end
       end
 
       def roles
-        data = ActiveModelSerializers::SerializableResource.new(@user.roles)
-        render json: { success: true, data: data }
+        render json: { success: true, data: serialize(set_object.roles) }
       end
 
       def assign_role
-        role = Cats::Core::Role.find(params[:role_id])
-        @user.roles << role
+        role = Role.find(params[:role_id])
+        user = set_object
+        user.roles << role
 
         case role.name
         when 'warehouse_manager'
-          @user.add_detail(:warehouse, params[:warehouse_id])
+          user.add_detail(:warehouse, params[:warehouse_id])
         when 'hub_manager'
-          @user.add_detail(:hub, params[:hub_id])
+          user.add_detail(:hub, params[:hub_id])
         when 'regional_manager'
-          @user.add_detail(:region, params[:region_id])
+          user.add_detail(:region, params[:region_id])
         end
 
-        data = ActiveModelSerializers::SerializableResource.new(role)
-        render json: { success: true, data: data }
+        render json: { success: true, data: serialize(role) }
       end
 
       def revoke_role
-        role = Cats::Core::Role.find(params[:role_id])
-        @user.roles.delete(role)
-        @user.remove_detail(role.name) if %w[warehouse_manager hub_manager regional_manager].include?(role.name)
-        data = ActiveModelSerializers::SerializableResource.new(role)
-        render json: { success: true, data: data }
+        user = set_object
+        role = Role.find(params[:role_id])
+        user.roles.delete(role)
+        user.remove_detail(role.name) if %w[warehouse_manager hub_manager regional_manager].include?(role.name)
+        render json: { success: true, data: serialize(role) }
       end
 
       def stores
-        data = ActiveModelSerializers::SerializableResource.new(@user.stores)
-        render json: { success: true, data: data }
+        render json: { success: true, data: serialize(set_object.stores) }
       end
 
       def warehouse
-        data = ActiveModelSerializers::SerializableResource.new(@user.warehouse)
-        render json: { success: true, data: data }
+        render json: { success: true, data: serialize(set_object.warehouse) }
       end
 
       def hub
-        data = ActiveModelSerializers::SerializableResource.new(@user.hub)
-        render json: { success: true, data: data }
+        render json: { success: true, data: serialize(set_object.hub) }
       end
 
       private
 
-      def set_user
-        @user = Cats::Core::User.find(params[:id])
-      end
-
       def model_params
         params.require(:payload).permit(
           :first_name, :last_name, :email, :phone_number, :active, :password, :password_confirmation, :details,

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

@@ -9,8 +9,12 @@ module Cats
       end
 
       def index
-        data = serialize(@clazz.all)
-        render json: { success: true, data: data }
+        data = if block_given?
+                 yield
+               else
+                 @clazz.all
+               end
+        render json: { success: true, data: serialize(data) }
       end
 
       def show
@@ -18,20 +22,33 @@ module Cats
       end
 
       def create
-        obj = @clazz.new(model_params)
+        obj = if block_given?
+                yield
+              else
+                @clazz.new(model_params)
+              end
         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
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
       end
 
       def update
-        if @obj.update(model_params)
-          render json: { success: true, data: serialize(@obj) }
+        obj = if block_given?
+                yield
+              else
+                obj = @obj
+              end
+        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
+          render json: { success: false, error: obj.errors.full_messages[0] }, status: :unprocessable_entity
         end
+      rescue StandardError => e
+        render json: { success: false, error: e.message }
       end
 
       private

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

@@ -37,6 +37,7 @@ module Cats
       validates :volume_per_metric_ton, numericality: { greater_than: 0, allow_nil: true }
       validates :arrival_status, presence: true, inclusion: { in: ARRIVAL_STATUSES }
       validates :status, presence: true, inclusion: { in: STATUSES }
+      validate :validate_updateability, on: :update
 
       delegate(:abbreviation, to: :unit_of_measure, prefix: 'unit')
       delegate(:reference_no, to: :source, prefix: true)
@@ -45,6 +46,14 @@ module Cats
         source.commodity_category.name
       end
 
+      def validate_updateability
+        return unless status
+
+        return if status_changed?
+
+        errors.add(:base, 'Commodity cannot be updated because it is in approved state.') if status == APPROVED
+      end
+
       def approve
         raise(StandardError, 'Commodity already approved.') if status == APPROVED
 

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

@@ -18,11 +18,24 @@ module Cats
       delegate(:full_name, to: :requested_by, prefix: 'requestor')
       delegate(:full_name, to: :approved_by, prefix: 'approver', allow_nil: true)
       delegate(:abbreviation, to: :unit, prefix: true)
+      delegate(:reference_no, to: :dispatch_plan, prefix: true)
 
       def quantity
         quantities = transport_requisition_items.map { |item| UnitConversion.convert(item.unit, unit, item.quantity) }
         quantities.sum
       end
+
+      def approve
+        raise(StandardError, 'Transport requisition is already approved.') if status == APPROVED
+
+        if transport_requisition_items.count.zero?
+          raise(StandardError, 'Transport requisition has no requisition items.')
+        end
+
+        self.status = APPROVED
+        save!
+        self
+      end
     end
   end
 end

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

@@ -9,6 +9,14 @@ module Cats
 
       delegate(:reference_no, to: :transport_requisition, prefix: 'requisition')
       delegate(:abbreviation, to: :unit, prefix: true)
+
+      def commodity_name
+        dispatch_plan_item.commodity.source.commodity_category.name
+      end
+
+      def woreda
+        dispatch_plan_item.destination.name
+      end
     end
   end
 end

data/lib/cats/core/version.rb

@@ -1,5 +1,5 @@
 module Cats
   module Core
-    VERSION = '1.4.6'.freeze
+    VERSION = '1.4.9'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cats_core
 version: !ruby/object:Gem::Version
-  version: 1.4.6
+  version: 1.4.9
 platform: ruby
 authors:
 - Henock L.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-18 00:00:00.000000000 Z
+date: 2022-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers