cats_core 1.4.8 → 1.4.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 626e9d30bfefd23124b2110a3b10c4a6dcf58ac6aeb660b50803843ececd2517
-  data.tar.gz: e59fa35f07c89486a5840e613389dd75ed6613077cb0ae3648295134dbff7ffe
+  metadata.gz: 76ca8cc4de9fdcbcc3f6a6b183fe9a8ec3b207e9fe0d60433a173eb854c9e482
+  data.tar.gz: 39c1d04223ff01f1d0ada3fc7b9587b2b0db778dd8e7d113ac262359dc8cbf2b
 SHA512:
-  metadata.gz: 440d92d2388b2816b1c76b0040d4c6d2a2fe0588b94e4ba134be56058cb74344ad55510e074a9d87ee04b1bf5336a705dd98bc7de5facc7250f3638f17e9ddfd
-  data.tar.gz: f3adb1d2cc5edd7cf7baf0eeb4b9624602f0987bea3cb5d1b7700af7b894ac43143fc2c0108daed5622e55e5581fc789ae97bd073a2246fdd02836bcb060784a
+  metadata.gz: e8b3bfbdf2c3f776f9a00c46453c7e720e217ca5a092e938371d256bd10f2f5751832464c73622a75728bc70e6588069125c2560308e1400b8e8fe3aa55a0427
+  data.tar.gz: '0768b2e8680b04b02293061ab4eb1adb884657c21c29457adca4c56f4c4583572784495bde0c09e0d52779c9ec59e1db426d4c0e8769b0f867759820bb494a0b'

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_order.rb

@@ -0,0 +1,24 @@
+module Cats
+  module Core
+    class TransportOrder < ApplicationRecord
+      DRAFT = 'Draft'.freeze
+      APPROVED = 'Approved'.freeze
+      STATUSES = [DRAFT, APPROVED].freeze
+
+      belongs_to :transport_requisition
+      belongs_to :prepared_by, class_name: 'Cats::Core::User'
+      belongs_to :approved_by, class_name: 'Cats::Core::User'
+
+      validates :status, presence: true, inclusion: { in: STATUSES }
+      validate :validate_against_requisition
+
+      def validate_against_requisition
+        return unless transport_requisition
+
+        return if transport_requisition.approved?
+
+        errors.add(:transport_requisition, 'is not approved.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Cats
+  module Core
+    class TransportOrderItem < ApplicationRecord
+      belongs_to :transport_order
+      belongs_to :transporter
+      belongs_to :transport_requisition_item
+      belongs_to :transport_contract, optional: true
+
+      validates :order_date, :valid_for, presence: true
+      validates :valid_for, numericality: { greater_than: 0 }
+      validates :transport_requisition_item_id, uniqueness: true
+      validate :validate_requisition
+
+      def validate_requisition
+        return unless transport_requisition_item
+
+        return unless transport_order
+
+        return if transport_order.transport_requisition_id == transport_requisition_item.transport_requisition_id
+
+        errors.add(:transport_requisition_item, 'does not belong to the requisition of the order.')
+      end
+    end
+  end
+end

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

@@ -14,6 +14,7 @@ module Cats
 
       validates :reference_no, presence: true, uniqueness: true
       validates :status, presence: true, inclusion: { in: STATUSES }
+      validate :validate_status
 
       delegate(:full_name, to: :requested_by, prefix: 'requestor')
       delegate(:full_name, to: :approved_by, prefix: 'approver', allow_nil: true)
@@ -28,13 +29,28 @@ module Cats
       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.') 
+        begin
+          self.status = APPROVED
+          save!
+          self
+        rescue ActiveRecord::RecordInvalid => e
+          error = e.record.errors.full_messages_for(:status)[0]
+          raise(StandardError, error)
         end
+      end
+
+      def approved?
+        status == APPROVED
+      end
+
+      def validate_status
+        return unless status
+
+        return if status == DRAFT
+
+        return if transport_requisition_items.count.positive?
 
-        self.status = APPROVED
-        save!
-        self
+        errors.add(:status, 'cannot be set to "APPROVED" because the requisition has no items.') if status == APPROVED
       end
     end
   end

data/db/migrate/20220506082329_create_cats_core_transport_orders.rb

@@ -0,0 +1,21 @@
+class CreateCatsCoreTransportOrders < ActiveRecord::Migration[7.0]
+  def change
+    create_table :cats_core_transport_orders do |t|
+      t.references :transport_requisition,
+                   null: false,
+                   index: { name: 'tr_on_to_indx' },
+                   foreign_key: { to_table: :cats_core_transport_requisitions }
+      t.references :prepared_by,
+                   null: false,
+                   index: { name: 'pb_on_to_indx' },
+                   foreign_key: { to_table: :cats_core_users }
+      t.references :approved_by,
+                   null: false,
+                   index: { name: 'ab_on_to_indx' },
+                   foreign_key: { to_table: :cats_core_users }
+      t.string :status, null: false, default: 'Draft'
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20220506083042_create_cats_core_transport_order_items.rb

@@ -0,0 +1,33 @@
+class CreateCatsCoreTransportOrderItems < ActiveRecord::Migration[7.0]
+  def change
+    create_table :cats_core_transport_order_items do |t|
+      t.references :transport_order,
+                   null: false,
+                   index: { name: 'to_on_toi_indx' },
+                   foreign_key: { to_table: :cats_core_transport_orders }
+      t.references :transporter,
+                   null: false,
+                   index: { name: 'transporter_on_toi_indx' },
+                   foreign_key: { to_table: :cats_core_transporters }
+      t.references :transport_contract,
+                   null: true,
+                   index: { name: 'tc_on_toi_indx' },
+                   foreign_key: { to_table: :cats_core_transport_contracts }
+      t.references :transport_requisition_item,
+                   null: false,
+                   index: { name: 'tri_on_toi_indx' },
+                   foreign_key: { to_table: :cats_core_transport_requisition_items }
+      t.date :order_date, null: false, default: Date.today
+      t.integer :valid_for, null: false, default: 10
+
+      t.timestamps
+    end
+
+    add_index(
+      :cats_core_transport_order_items,
+      :transport_requisition_item_id,
+      unique: true,
+      name: 'tri_on_toi_uniq_indx'
+    )
+  end
+end

data/lib/cats/core/version.rb

@@ -1,5 +1,5 @@
 module Cats
   module Core
-    VERSION = '1.4.8'.freeze
+    VERSION = '1.4.11'.freeze
   end
 end

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

@@ -0,0 +1,10 @@
+FactoryBot.define do
+  factory :transport_order_item, class: 'Cats::Core::TransportOrderItem' do
+    transport_order
+    transporter
+    transport_contract
+    transport_requisition_item { transport_order.transport_requisition.transport_requisition_items.first }
+    order_date { Date.today }
+    valid_for { 10 }
+  end
+end

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

@@ -0,0 +1,8 @@
+FactoryBot.define do
+  factory :transport_order, class: 'Cats::Core::TransportOrder' do
+    association :transport_requisition, :approved
+    prepared_by factory: :user
+    approved_by factory: :user
+    status { Cats::Core::TransportOrder::DRAFT }
+  end
+end

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

@@ -6,5 +6,12 @@ FactoryBot.define do
     approved_by factory: :user
     status { Cats::Core::TransportRequisition::DRAFT }
     unit factory: :unit_of_measure
+
+    trait :approved do
+      after(:create) do |requisition|
+        create(:transport_requisition_item, transport_requisition: requisition)
+        requisition.approve
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cats_core
 version: !ruby/object:Gem::Version
-  version: 1.4.8
+  version: 1.4.11
 platform: ruby
 authors:
 - Henock L.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-18 00:00:00.000000000 Z
+date: 2022-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -307,6 +307,8 @@ files:
 - app/models/cats/core/transport_bid_item.rb
 - app/models/cats/core/transport_contract.rb
 - app/models/cats/core/transport_offer.rb
+- app/models/cats/core/transport_order.rb
+- app/models/cats/core/transport_order_item.rb
 - app/models/cats/core/transport_plan.rb
 - app/models/cats/core/transport_plan_item.rb
 - app/models/cats/core/transport_requisition.rb
@@ -410,6 +412,8 @@ files:
 - db/migrate/20220417105839_create_cats_core_transport_requisitions.rb
 - db/migrate/20220417123835_create_cats_core_transport_requisition_items.rb
 - db/migrate/20220417151821_create_cats_core_transport_requisition_details.rb
+- db/migrate/20220506082329_create_cats_core_transport_orders.rb
+- db/migrate/20220506083042_create_cats_core_transport_order_items.rb
 - lib/cats/core.rb
 - lib/cats/core/engine.rb
 - lib/cats/core/version.rb
@@ -464,6 +468,8 @@ files:
 - spec/factories/cats/core/transport_bids.rb
 - spec/factories/cats/core/transport_contracts.rb
 - spec/factories/cats/core/transport_offers.rb
+- spec/factories/cats/core/transport_order_items.rb
+- spec/factories/cats/core/transport_orders.rb
 - spec/factories/cats/core/transport_plan_items.rb
 - spec/factories/cats/core/transport_plans.rb
 - spec/factories/cats/core/transport_requisition_details.rb