cats_core 1.5.16 → 1.5.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 279f9103030fd0c0a858e6d2d5c2f71b69644f17b3654b7e8cd6226deeefabb3
-  data.tar.gz: 58431c85a8824cd879b58f550fa28969b1f45bd9ba04cb16ab69553a6e01c3d3
+  metadata.gz: 8600827ecd1928a38a51faaac12c7fa5b99aabbe60f9d8f8bca25bd6ebb5ff12
+  data.tar.gz: 49b53ed37b83474a1fe315625edae660dce4307100f2a431d4b480e74a10cfb1
 SHA512:
-  metadata.gz: e3f8d565b6b939cadff349df0add73ba2e50ae4eef45629d412748754e307aaf7952b69bf3138232c549c560766f23e8dcfbceb5b14ae3f7b3ddccb9c428ab92
-  data.tar.gz: e3d1c7576b48388d6f8144401218b47fd2d40b0320f1ffbe6f9ef674e70d2ab295aed46fb2ac6d9571ca0c99d611f529dc047d3e073bde557d9e02a9c726fb77
+  metadata.gz: f56b80a25dbb39a4483888e722f884d46776f1c15a00d0fbd7596fcd0aab462c1a35a5d3adcfa4d4f599310f7b3d5b85079bb2794583f464286331b61b624003
+  data.tar.gz: 4074542f2decf95e6becf28b2cd83c438d1f141638d13ae1b33b523d1b650aa00dc8e50192ae8c4bcf4b985a95e3bc8bcd7c78dece4921363309d94549eb05cc

data/Rakefile

@@ -1,10 +1,10 @@
-require 'bundler/setup'
+require "bundler/setup"
 
-APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
-load 'rails/tasks/engine.rake'
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
 
-load 'rails/tasks/statistics.rake'
+load "rails/tasks/statistics.rake"
 
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(spec: 'app:db:test:prepare')
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(spec: "app:db:test:prepare")

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

@@ -10,7 +10,7 @@ module Cats
             roles = user.roles.map(&:name)
 
             unless roles.count.positive?
-              render json: { error: 'User has no roles.' }, status: :unprocessable_entity
+              render json: {error: "User has no roles."}, status: :unprocessable_entity
               return
             end
 
@@ -19,12 +19,12 @@ module Cats
               details: user.details
             }
             jwt = TokenAuthService.issue(payload)
-            render json: { token: jwt, user: payload }
+            render json: {token: jwt, user: payload}
           else
-            render json: { error: 'Invalid password.' }, status: 400
+            render json: {error: "Invalid password."}, status: 400
           end
         else
-          render json: { error: 'User does not exist.' }, status: 400
+          render json: {error: "User does not exist."}, status: 400
         end
       end
 

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

@@ -6,12 +6,12 @@ module Cats
       def current_user
         return if token.nil?
 
-        user = User.find(auth['id'])
+        user = User.find(auth["id"])
         @current_user ||= user
       end
 
       def authenticate
-        render json: { error: 'Unauthorized' }, status: 401 if current_user.nil?
+        render json: {error: "Unauthorized"}, status: 401 if current_user.nil?
       end
 
       # In case we want to disable bullet for specific controller actions
@@ -30,9 +30,9 @@ module Cats
       end
 
       def token
-        return nil if request.env['HTTP_AUTHORIZATION'].nil?
+        return nil if request.env["HTTP_AUTHORIZATION"].nil?
 
-        request.env['HTTP_AUTHORIZATION'].scan(/Bearer (.*)$/).flatten.last
+        request.env["HTTP_AUTHORIZATION"].scan(/Bearer (.*)$/).flatten.last
       end
 
       def auth

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

@@ -5,29 +5,29 @@ module Cats
 
       def index
         super do
-          Commodity.all.includes({ project: { source: :commodity_category } }, :unit_of_measure, :package_unit)
+          Commodity.all.includes({project: {source: :commodity_category}}, :unit_of_measure, :package_unit)
         end
       end
 
       def approve
         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 }
+        render json: {success: result, data: serialize(commodity)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def filter
         query = Commodity.includes(:project, :unit_of_measure, :package_unit).ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       private
 
       def model_params
         params.require(:payload).permit(:batch_no, :description, :unit_of_measure_id, :project_id, :commodity_grade,
-                                        :source_type, :quantity, :best_use_before, :volume_per_metric_ton,
-                                        :arrival_status, :shipping_reference, :package_unit_id)
+          :source_type, :quantity, :best_use_before, :volume_per_metric_ton,
+          :arrival_status, :shipping_reference, :package_unit_id)
       end
     end
   end

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

@@ -11,23 +11,23 @@ module Cats
 
       def all
         data = CommodityCategory.all
-        render json: { success: true, data: data }
+        render json: {success: true, data: data}
       end
 
       def root
         data = CommodityCategory.roots
-        render json: { success: true, data: serialize(data) }
+        render json: {success: true, data: serialize(data)}
       end
 
       def children
         parent = CommodityCategory.find(params[:id])
-        render json: { success: true, data: serialize(parent.children) }
+        render json: {success: true, data: serialize(parent.children)}
       end
 
       private
 
       def model_params
-        params.require('payload').permit(:code, :name, :description, :parent_id)
+        params.require("payload").permit(:code, :name, :description, :parent_id)
       end
     end
   end

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

@@ -5,25 +5,48 @@ module Cats
 
       def index
         super do
-          DispatchAuthorization.includes(:dispatch, :store, :authorized_by, :unit).where(dispatch_id: params[:id])
+          DispatchAuthorization.includes(:dispatch, :store, :authorized_by, :unit).where(
+            dispatch_id: params[:id]
+          ).reverse_order
+        end
+      end
+
+      def create
+        authorization = DispatchAuthorization.new(model_params)
+        if authorization.save
+          AuthorizationService.new.send_dispatch_notification(authorization)
+          render json: {success: true, data: serialize(authorization)}, status: :created
+        else
+          render json: {success: false, error: authorization.errors.full_messages[0]}, status: :unprocessable_entity
         end
       end
 
       def confirm
         authorization = DispatchAuthorization.find(params[:id])
         authorization = authorization.confirm
-        render json: { success: true, data: serialize(authorization) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: true, data: serialize(authorization)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def storekeeper_authorizations
         storekeeper = User.find(params[:id])
         stores = storekeeper.stores
         authorizations = DispatchAuthorization.joins(:dispatch)
-                                              .includes(:dispatch, :store, :authorized_by, :unit)
-                                              .where(store: stores, dispatch: { dispatch_status: Dispatch::APPROVED })
-        render json: { success: true, data: serialize(authorizations) }
+          .includes(:dispatch, :store, :authorized_by, :unit)
+          .where(store: stores, dispatch: {dispatch_status: Dispatch::APPROVED})
+          .reverse_order
+        render json: {success: true, data: serialize(authorizations)}
+      end
+
+      def filter
+        query = DispatchAuthorization.includes(
+          :dispatch,
+          :store,
+          :authorized_by,
+          :unit
+        ).ransack(params[:q])
+        render json: {success: true, data: serialize(query.result.reverse_order)}
       end
 
       private

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

@@ -8,7 +8,7 @@ module Cats
           DispatchPlanItem.includes(
             :source,
             :destination,
-            { commodity: { project: { source: :commodity_category } } },
+            {commodity: {project: {source: :commodity_category}}},
             :unit,
             :dispatch_plan
           ).where(dispatch_plan_id: params[:id])
@@ -19,18 +19,18 @@ module Cats
         query = DispatchPlanItem.includes(
           :source,
           :destination,
-          { commodity: { project: { source: :commodity_category } } },
+          {commodity: {project: {source: :commodity_category}}},
           :unit,
           :dispatch_plan
         ).ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       private
 
       def model_params
         params.require(:payload).permit(:reference_no, :dispatch_plan_id, :source_id, :destination_id, :quantity,
-                                        :unit_id, :commodity_status, :status, :commodity_id)
+          :unit_id, :commodity_status, :status, :commodity_id)
       end
     end
   end

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

@@ -11,41 +11,41 @@ module Cats
 
       def plans_for_user
         plans = DispatchPlan.where(prepared_by: current_user).includes(:dispatchable)
-        render json: { success: true, data: serialize(plans) }
+        render json: {success: true, data: serialize(plans)}
       end
 
       def filter
         query = DispatchPlan.ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       def create
         service = DispatchPlanService.new
         plan = service.create(model_params, current_user)
-        render json: { success: true, data: serialize(plan) }, status: :created
-      rescue StandardError => e
-        render json: { success: false, error: e.message }, status: :unprocessable_entity
+        render json: {success: true, data: serialize(plan)}, status: :created
+      rescue => e
+        render json: {success: false, error: e.message}, status: :unprocessable_entity
       end
 
       def generate
         service = DispatchPlanService.new
         items = service.generate(params[:id])
-        render json: { success: true, data: serialize(items) }
+        render json: {success: true, data: serialize(items)}
       end
 
       def bulk_create
         service = DispatchPlanService.new
         plan = service.bulk_create(bulk_create_params, current_user)
-        render json: { success: true, data: serialize(plan) }
+        render json: {success: true, data: serialize(plan)}
       end
 
       def approve
         service = DispatchPlanService.new
         plan = DispatchPlan.find(params[:id])
         plan = service.approve(plan)
-        render json: { success: true, data: serialize(plan) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: true, data: serialize(plan)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       private

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

@@ -19,26 +19,26 @@ module Cats
         transaction = DispatchTransaction.new(model_params)
 
         # Fetch supplier stack by commodity
-        stack = Stack.joins(:store).find_by(commodity: commodity, store: { code: 'SUP-STORE' })
+        stack = Stack.joins(:store).find_by(commodity: commodity, store: {code: "SUP-STORE"})
         transaction.source = stack
 
         if transaction.save
-          render json: { success: true, data: serialize(transaction) }, status: :created
+          render json: {success: true, data: serialize(transaction)}, status: :created
         else
-          render json: { success: false, error: transaction.errors.full_messages[0] }, status: :unprocessable_entity
+          render json: {success: false, error: transaction.errors.full_messages[0]}, status: :unprocessable_entity
         end
       end
 
       def filter
         query = DispatchTransaction.ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       private
 
       def model_params
         params.require(:payload).permit(:source_id, :dispatch_authorization_id, :transaction_date, :quantity, :unit_id,
-                                        :reference_no)
+          :reference_no)
       end
     end
   end

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

@@ -9,11 +9,11 @@ module Cats
       def index
         super do
           Dispatch.includes(
-            { dispatch_plan_item: :destination },
+            {dispatch_plan_item: :destination},
             :transporter,
             :prepared_by,
             :unit
-          ).where(dispatch_plan_item_id: params[:id])
+          ).where(dispatch_plan_item_id: params[:id]).reverse_order
         end
       end
 
@@ -29,51 +29,51 @@ module Cats
       def approve
         dispatch = set_object
         dispatch.approve
-        render json: { success: true, data: serialize(dispatch) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: true, data: serialize(dispatch)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def start
         dispatch = @service.start(set_object)
-        render json: { success: true, data: serialize(dispatch) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: true, data: serialize(dispatch)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def start_with_pin
         dispatch = @service.start_with_pin(params[:id], start_with_pin_params[:pin])
-        render json: { success: true, data: serialize(dispatch) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: true, data: serialize(dispatch)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def confirm
         dispatch = set_object
         dispatch.confirm
-        render json: { success: true, data: serialize(dispatch) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: true, data: serialize(dispatch)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def filter
         query = Dispatch.includes(
-          { dispatch_plan_item: :destination },
+          {dispatch_plan_item: :destination},
           :transporter,
           :prepared_by,
           :unit
         ).ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result.reverse_order)}
       end
 
       def search
         data = @service.search(current_user, params[:status])
-        render json: { success: true, data: serialize(data) }
+        render json: {success: true, data: serialize(data)}
       end
 
       def commodity
         data = set_object.dispatch_plan_item.commodity
-        render json: { success: true, data: serialize(data) }
+        render json: {success: true, data: serialize(data)}
       end
 
       private
@@ -84,7 +84,7 @@ module Cats
 
       def model_params
         params.require(:payload).permit(:reference_no, :dispatch_plan_item_id, :transporter_id, :plate_no, :unit_id,
-                                        :driver_name, :driver_phone, :remark)
+          :driver_name, :driver_phone, :remark)
       end
 
       def start_with_pin_params

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

@@ -13,7 +13,7 @@ module Cats
 
       def model_params
         params.require(:payload).permit(:reference_no, :description, :lender, :agreement_date, :repayment_date,
-                                        :quantity, :unit_id, :commodity_category_id)
+          :quantity, :unit_id, :commodity_category_id)
       end
     end
   end

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

@@ -11,25 +11,25 @@ module Cats
 
       def children
         parent = Location.find(params[:id])
-        render json: { success: true, data: serialize(parent.children) }
+        render json: {success: true, data: serialize(parent.children)}
       end
 
       def filter
         query = Location.ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       def woredas
         region = Location.find(params[:id])
         woredas = Location.where(id: region.descendant_ids, location_type: Location::WOREDA)
-        render json: { success: true, data: serialize(woredas) }
+        render json: {success: true, data: serialize(woredas)}
       end
 
       def create_fdp
         service = LocationService.new
         p = fdp_params
         fdp = service.create_fdp(p[:code], p[:name], p[:parent_id], p[:description])
-        render json: { success: true, data: serialize(fdp) }
+        render json: {success: true, data: serialize(fdp)}
       end
 
       private

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

@@ -6,7 +6,7 @@ module Cats
       def index
         menu = @service.fetch_menu(current_user)
         data = ActiveModelSerializers::SerializableResource.new(menu, each_serializer: RoleMenuSerializer)
-        render json: { success: true, data: data }
+        render json: {success: true, data: data}
       end
 
       private

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

@@ -5,27 +5,27 @@ module Cats
 
       def index
         data = Notification.messages(current_user.notifications.newest_first)
-        render json: { success: true, data: data }
+        render json: {success: true, data: data}
       end
 
       def read
         data = Notification.messages(current_user.notifications.read.newest_first)
-        render json: { success: true, data: data }
+        render json: {success: true, data: data}
       end
 
       def unread
         data = Notification.messages(current_user.notifications.unread.newest_first)
-        render json: { success: true, data: data }
+        render json: {success: true, data: data}
       end
 
       def mark_as_read
         @notification.mark_as_read!
-        render json: { success: true, data: @notification.message }
+        render json: {success: true, data: @notification.message}
       end
 
       def mark_as_unread
         @notification.mark_as_unread!
-        render json: { success: true, data: @notification.message }
+        render json: {success: true, data: @notification.message}
       end
 
       private

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

@@ -9,15 +9,15 @@ module Cats
           :unit,
           :currency
         )
-        render json: { success: true, data: serialize(purchase_orders) }
+        render json: {success: true, data: serialize(purchase_orders)}
       end
 
       private
 
       def model_params
         params.require(:payload).permit(:reference_no, :order_date, :requisition_no, :supplier, :cash_donation_id,
-                                        :commodity_category_id, :quantity, :purchase_type, :unit_id, :price,
-                                        :currency_id, :description)
+          :commodity_category_id, :quantity, :purchase_type, :unit_id, :price,
+          :currency_id, :description)
       end
     end
   end

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

@@ -7,43 +7,45 @@ module Cats
 
       def index
         super do
-          ReceiptAuthorization.includes(:dispatch, :store, :authorized_by, :unit).where(dispatch_id: params[:id])
+          ReceiptAuthorization.includes(:dispatch, :store, :authorized_by, :unit).where(dispatch_id: params[:id]).reverse_order
         end
       end
 
       def create
         authorization = ReceiptAuthorization.new(model_params)
         if authorization.save
-          AuthorizationService.new.send_notification(authorization)
-          render json: { success: true, data: serialize(authorization) }, status: :created
+          AuthorizationService.new.send_receipt_notification(authorization)
+          render json: {success: true, data: serialize(authorization)}, status: :created
         else
-          render json: { success: false, error: authorization.errors.full_messages[0] }, status: :unprocessable_entity
+          render json: {success: false, error: authorization.errors.full_messages[0]}, status: :unprocessable_entity
         end
       end
 
       def confirm
         authorization = ReceiptAuthorization.find(params[:id])
         authorization.confirm
-        render json: { success: true, data: serialize(authorization) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: true, data: serialize(authorization)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def driver_confirm
         service = AuthorizationService.new
-        authorization = service.driver_confirm(params[:id], driver_confirm_params[:pin])
-        render json: { success: true, data: serialize(authorization) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        authorization = service.driver_confirm(
+          params[:id], driver_confirm_params[:pin], driver_confirm_params[:receipt_number]
+        )
+        render json: {success: true, data: serialize(authorization)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def stack
         service = AuthorizationService.new
         authorization = ReceiptAuthorization.find(params[:id])
         authorization = service.stack(authorization.id)
-        render json: { success: true, data: serialize(authorization) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: true, data: serialize(authorization)}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def storekeeper_authorizations
@@ -51,19 +53,29 @@ module Cats
         status = params[:status]
         stores = storekeeper.stores
         authorizations = ReceiptAuthorization.includes(:dispatch, :store, :authorized_by, :unit)
-                                             .where(store: stores, status: status)
-        render json: { success: true, data: serialize(authorizations) }
+          .where(store: stores, status: status)
+        render json: {success: true, data: serialize(authorizations)}
+      end
+
+      def filter
+        query = ReceiptAuthorization.includes(
+          :dispatch,
+          :store,
+          :authorized_by,
+          :unit
+        ).ransack(params[:q])
+        render json: {success: true, data: serialize(query.result.reverse_order)}
       end
 
       private
 
       def model_params
         params.require(:payload).permit(:dispatch_id, :store_id, :quantity, :unit_id, :remark, :status,
-                                        :authorized_by_id)
+          :authorized_by_id)
       end
 
       def driver_confirm_params
-        params.require(:payload).permit(:pin)
+        params.require(:payload).permit(:pin, :receipt_number)
       end
     end
   end

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

@@ -5,21 +5,21 @@ module Cats
 
       def index
         super do
-          ReceiptTransaction.includes(:destination, { receipt_authorization: :dispatch }, :unit)
-                            .where(receipt_authorization_id: params[:id])
+          ReceiptTransaction.includes(:destination, {receipt_authorization: :dispatch}, :unit)
+            .where(receipt_authorization_id: params[:id])
         end
       end
 
       def filter
         query = ReceiptTransaction.ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       private
 
       def model_params
         params.require(:payload).permit(:receipt_authorization_id, :receipt_number, :destination_id,
-                                        :transaction_date, :quantity, :unit_id)
+          :transaction_date, :quantity, :unit_id)
       end
     end
   end

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

@@ -13,7 +13,7 @@ module Cats
 
       def model_params
         params.require(:payload).permit(:receipt_authorization_id, :commodity_status, :commodity_grade, :quantity,
-                                        :unit_id, :remark, :reference_no)
+          :unit_id, :remark, :reference_no)
       end
     end
   end