cats_core 1.4.7 → 1.4.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd88ba053bde7688e286bd43301fbd8b7d8c09eb3d76a22c5da0f70c80f8f733
-  data.tar.gz: 3377e493badbe09bd8d152bb93aad0843b427e72fad83273eeb5177257fc7dd0
+  metadata.gz: 5c497f5ed7c7fd9a82dd7a8f2450db08ab9e6ea307cfebf448819c15affe9baa
+  data.tar.gz: 0c7514559659448cf6b1b83381b3eda706b37497b7fc2d4e2556430c50cfe21a
 SHA512:
-  metadata.gz: 011ad9d0b3d1906c2cd7a3f978d5a2116c37af34bb199f1c52618682cc49064abcf533543cb088026f10d06b658cfbb40b21eccfb4d045605f4d93a55b729f47
-  data.tar.gz: 605b33ec788fff1f0514e7093f4d03698de791f84bd49744856664f045349570bf767ed767e31eded4ef0206902f3e7d07f3686796d31e219baf4d0c21c2ecab
+  metadata.gz: cda6953720eb9492fd45083008ab61c38dc28ed1d7f1995f882335725d9f2beeb07b4e1bf1b012eddb6639bce628c6c3e98c939fe6ce59d18ad450d91bd17ffc
+  data.tar.gz: 8785eba470967b8c6b765363c9c88d27270e482a1196decc995182030a6448160590eabe0bb696fabcdceed73e59f17cfffd2c6edb88d9870b4c45fe496652e7

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)
@@ -24,6 +25,33 @@ module Cats
         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
+
+        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?
+
+        errors.add(:status, 'cannot be set to "APPROVED" because the requisition has no items.') if status == APPROVED
+      end
     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.7'.freeze
+    VERSION = '1.4.10'.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,13 @@
+FactoryBot.define do
+  factory :transport_order, class: 'Cats::Core::TransportOrder' do
+    transport_requisition do
+      requisition = create(:transport_requisition)
+      create(:transport_requisition_item, transport_requisition: requisition)
+      requisition.approve
+      requisition
+    end
+    prepared_by factory: :user
+    approved_by factory: :user
+    status { Cats::Core::TransportOrder::DRAFT }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cats_core
 version: !ruby/object:Gem::Version
-  version: 1.4.7
+  version: 1.4.10
 platform: ruby
 authors:
 - Henock L.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-18 00:00:00.000000000 Z
+date: 2022-05-07 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