cats_core 1.5.16 → 1.5.18

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

@@ -8,7 +8,7 @@ module Cats
       def index
         super do
           Role.joins(:application_module)
-              .where(cats_core_application_modules: { prefix: params[:prefix] })
+            .where(cats_core_application_modules: {prefix: params[:prefix]})
         end
       end
 
@@ -16,11 +16,11 @@ module Cats
         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) }
+        render json: {success: true, data: serialize(unassigned)}
       end
 
       def users
-        render json: { success: true, data: serialize(@role.users) }
+        render json: {success: true, data: serialize(@role.users)}
       end
 
       private

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

@@ -5,38 +5,38 @@ module Cats
 
       def index
         beneficiaries = RoundBeneficiary.joins(:round_plan_item)
-                                        .where(round_plan_item: { round_plan_id: params[:id] })
-                                        .includes(:beneficiary, :commodity_category, :unit)
-        render json: { success: true, data: serialize(beneficiaries) }
+          .where(round_plan_item: {round_plan_id: params[:id]})
+          .includes(:beneficiary, :commodity_category, :unit)
+        render json: {success: true, data: serialize(beneficiaries)}
       end
 
       def generate
         service = BeneficiaryService.new
         result = service.generate_distribution_list(params[:id])
-        render json: { success: result }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: result}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def filter
         query = RoundBeneficiary.includes(:beneficiary, :commodity_category, :unit).ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       def remove_beneficiaries
         service = BeneficiaryService.new
         result = service.remove_items(params[:id], common_params[:ids])
-        render json: { success: result }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: result}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def confirm_receipt
         service = BeneficiaryService.new
         result = service.confirm_receipt(params[:id], common_params[:ids])
-        render json: { success: result }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }
+        render json: {success: result}
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       private

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

@@ -8,40 +8,40 @@ module Cats
 
       def index
         super do
-          RoundPlan.includes({ plan: :program }, :region).where(plan: params[:id])
+          RoundPlan.includes({plan: :program}, :region).where(plan: params[:id])
         end
       end
 
       def filter
-        query = RoundPlan.includes({ plan: :program }, :region).ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        query = RoundPlan.includes({plan: :program}, :region).ransack(params[:q])
+        render json: {success: true, data: serialize(query.result)}
       end
 
       def approve
         plan = @service.approve(params[:id])
-        render json: { success: true, data: serialize(plan) }
-      rescue StandardError => e
-        render json: { success: false, error: e.message }, status: :unprocessable_entity
+        render json: {success: true, data: serialize(plan)}
+      rescue => e
+        render json: {success: false, error: e.message}, status: :unprocessable_entity
       end
 
       def generate
         p = model_params
         plan = @service.generate_round_plan(p[:reference_no], p[:rounds], p[:plan_id], p[:region_id])
-        render json: { success: true, data: serialize(plan) }
+        render json: {success: true, data: serialize(plan)}
       end
 
       def generate_round_needs
         plan = @service.generate_round_needs(params[:id])
-        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
 
       def remove_items
         plan = @service.remove_items(params[:id], remove_params[:ids])
-        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/routes_controller.rb

@@ -11,7 +11,7 @@ module Cats
 
       def filter
         query = Route.includes(:region).ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       def bulk_create
@@ -30,7 +30,7 @@ module Cats
 
         result = Route.insert_all!(data, record_timestamps: true)
         routes = Route.includes(:region).where(id: result.rows.flatten)
-        render json: { success: true, data: serialize(routes) }
+        render json: {success: true, data: serialize(routes)}
       end
 
       private

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

@@ -4,7 +4,7 @@ module Cats
       def available_space
         service = SpaceService.new
         space = service.available_space(params[:id], params[:level])
-        render json: { success: true, data: space }
+        render json: {success: true, data: space}
       end
     end
   end

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

@@ -5,14 +5,14 @@ module Cats
 
       def index
         super do
-          StackTransaction.joins({ source: :store }, :unit)
-                          .where(cats_core_stacks: { cats_core_stores: { warehouse_id: params[:id] } })
+          StackTransaction.joins({source: :store}, :unit)
+            .where(cats_core_stacks: {cats_core_stores: {warehouse_id: params[:id]}})
         end
       end
 
       def filter
         query = StackTransaction.ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       private

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

@@ -11,13 +11,13 @@ module Cats
 
       def filter
         query = Stack.includes(:commodity, :unit).where(store_id: params[:id]).ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       def items_for_location
         service = StackService.new
         commodities = service.items_for_location(current_user)
-        render json: { success: true, data: serialize(commodities) }
+        render json: {success: true, data: serialize(commodities)}
       end
 
       def dispatch_stacks
@@ -26,25 +26,33 @@ module Cats
         stacks = service.dispatch_stacks(dispatch)
 
         # Filter for current user
-        if current_user.details.key?('stores')
-          stores = current_user.details['stores']
+        if current_user.details.key?("stores")
+          stores = current_user.details["stores"]
           stacks = stacks.select { |stack| stores.include?(stack.store_id) }
         end
-        render json: { success: true, data: serialize(stacks) }
+        render json: {success: true, data: serialize(stacks)}
       end
 
       def receipt_stacks
         service = StackService.new
         authorization = ReceiptAuthorization.find(params[:id])
         stacks = service.receipt_stacks(authorization.id)
-        render json: { success: true, data: serialize(stacks) }
+        render json: {success: true, data: serialize(stacks)}
+      end
+
+      def destroy
+        stack = set_object
+        stack.destroy_stack
+        render json: {success: true, data: serialize(stack)}
+      rescue => e
+        render json: {success: false, error: e}
       end
 
       private
 
       def model_params
         params.require(:payload).permit(:code, :length, :width, :height, :start_x, :start_y, :commodity_id, :store_id,
-                                        :commodity_status, :stack_status, :quantity, :unit_id)
+          :commodity_status, :stack_status, :quantity, :unit_id)
       end
     end
   end

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

@@ -5,38 +5,38 @@ module Cats
 
       def index
         stores = Store.includes(:stacks).where(warehouse_id: params[:id])
-        render json: { success: true, data: serialize(stores) }
+        render json: {success: true, data: serialize(stores)}
       end
 
       def filter
         query = Store.includes(:stacks).ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       def stores_for_hub
         warehouses = Location.find(params[:id]).children
         ids = warehouses.map(&:id)
         stores = Store.includes(:stacks).where(warehouse_id: ids)
-        render json: { success: true, data: serialize(stores) }
+        render json: {success: true, data: serialize(stores)}
       end
 
       def assign_store
         store_keeper = User.find(params[:id])
-        store_keeper.details['stores'] ||= []
-        store_keeper.details['stores'] += store_params[:store_ids]
+        store_keeper.details["stores"] ||= []
+        store_keeper.details["stores"] += store_params[:store_ids]
         store_keeper.save!
 
-        render json: { success: true, data: serialize(store_keeper) }
+        render json: {success: true, data: serialize(store_keeper)}
       end
 
       def unassign_store
         store_keeper = User.find(params[:id])
-        if store_keeper.details.key?('stores')
-          store_keeper.details['stores'] -= store_params[:store_ids]
+        if store_keeper.details.key?("stores")
+          store_keeper.details["stores"] -= store_params[:store_ids]
           store_keeper.save!
-          render json: { success: true, data: serialize(store_keeper) }
+          render json: {success: true, data: serialize(store_keeper)}
         else
-          render json: { success: false, error: 'User has no stores assigned.' }
+          render json: {success: false, error: "User has no stores assigned."}
         end
       end
 
@@ -44,17 +44,17 @@ module Cats
         store = Store.find(params[:id])
         location = store.warehouse.parent
         if location.location_type == Location::FDP
-          render json: { success: true, data: serialize(location) }
+          render json: {success: true, data: serialize(location)}
         else
-          render json: { success: false, error: 'No FDP is associated with store.' }
+          render json: {success: false, error: "No FDP is associated with store."}
         end
       end
 
       private
 
       def model_params
-        params.require('payload').permit(:id, :code, :name, :length, :width, :height, :temporary, :has_gangway,
-                                         :gangway_length, :gangway_width, :gangway_corner_dist, :warehouse_id)
+        params.require("payload").permit(:id, :code, :name, :length, :width, :height, :temporary, :has_gangway,
+          :gangway_length, :gangway_width, :gangway_corner_dist, :warehouse_id)
       end
 
       def store_params

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

@@ -13,8 +13,8 @@ module Cats
 
       def model_params
         params.require(:payload).permit(:reference_no, :swapper, :agreement_date, :issued_commodity_id, :description,
-                                        :issued_quantity, :received_commodity_id, :received_quantity, :issued_unit_id,
-                                        :received_unit_id)
+          :issued_quantity, :received_commodity_id, :received_quantity, :issued_unit_id,
+          :received_unit_id)
       end
     end
   end

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

@@ -5,7 +5,7 @@ module Cats
 
       def filter
         query = Transporter.ransack(params[:q])
-        render json: { success: true, data: serialize(query.result) }
+        render json: {success: true, data: serialize(query.result)}
       end
 
       private

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

@@ -3,11 +3,12 @@ module Cats
     class UsersController < ApplicationController
       include Common
 
+      skip_before_action :authenticate, only: [:change_password]
       around_action :skip_bullet, if: -> { defined?(Bullet) }, only: %i[stores]
 
       def index
         super do
-          User.joins(:application_module).where(cats_core_application_modules: { prefix: params[:prefix] })
+          User.joins(:application_module).where(cats_core_application_modules: {prefix: params[:prefix]})
         end
       end
 
@@ -34,14 +35,25 @@ module Cats
         end
 
         if user.save
-          render json: { success: true, data: serialize(user) }
+          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 change_password
+        service = UserService.new
+        payload = params.require(:payload).permit(:email, :old_password, :password, :password_confirmation)
+        email, old_pass, new_pass, confirmation = *payload.values
+        user = service.change_password(email, old_pass, new_pass, confirmation)
+
+        render json: {success: true, data: serialize(user)}
+      rescue => e
+        render json: {success: false, error: e}
+      end
+
       def roles
-        render json: { success: true, data: serialize(set_object.roles) }
+        render json: {success: true, data: serialize(set_object.roles)}
       end
 
       def assign_role
@@ -50,15 +62,15 @@ module Cats
         user.roles << role
 
         case role.name
-        when 'warehouse_manager'
+        when "warehouse_manager"
           user.add_detail(:warehouse, params[:warehouse_id])
-        when 'hub_manager'
+        when "hub_manager"
           user.add_detail(:hub, params[:hub_id])
-        when 'regional_manager'
+        when "regional_manager"
           user.add_detail(:region, params[:region_id])
         end
 
-        render json: { success: true, data: serialize(role) }
+        render json: {success: true, data: serialize(role)}
       end
 
       def revoke_role
@@ -66,19 +78,19 @@ module Cats
         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) }
+        render json: {success: true, data: serialize(role)}
       end
 
       def stores
-        render json: { success: true, data: serialize(set_object.stores) }
+        render json: {success: true, data: serialize(set_object.stores)}
       end
 
       def warehouse
-        render json: { success: true, data: serialize(set_object.warehouse) }
+        render json: {success: true, data: serialize(set_object.warehouse)}
       end
 
       def hub
-        render json: { success: true, data: serialize(set_object.hub) }
+        render json: {success: true, data: serialize(set_object.hub)}
       end
 
       private

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

@@ -10,45 +10,45 @@ module Cats
 
       def index
         data = if block_given?
-                 yield
-               else
-                 @clazz.all
-               end
-        render json: { success: true, data: serialize(data) }
+          yield
+        else
+          @clazz.all
+        end
+        render json: {success: true, data: serialize(data)}
       end
 
       def show
-        render json: { success: true, data: serialize(@obj) }
+        render json: {success: true, data: serialize(@obj)}
       end
 
       def create
         obj = if block_given?
-                yield
-              else
-                @clazz.new(model_params)
-              end
+          yield
+        else
+          @clazz.new(model_params)
+        end
         if obj.save
-          render json: { success: true, data: serialize(obj) }, status: :created
+          render json: {success: true, data: serialize(obj)}, status: :created
         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 }
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       def update
         obj = if block_given?
-                yield
-              else
-                obj = @obj
-              end
+          yield
+        else
+          obj = @obj
+        end
         if obj.update(model_params)
-          render json: { success: true, data: serialize(obj) }
+          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 }
+      rescue => e
+        render json: {success: false, error: e.message}
       end
 
       private
@@ -66,7 +66,8 @@ module Cats
       end
 
       # This class should be overridden by respective child controllers
-      def model_params; end
+      def model_params
+      end
     end
   end
 end

data/app/helpers/cats/core/document_helper.rb

@@ -1,7 +1,7 @@
 module Cats
   module Core
     module DocumentHelper
-      require 'sablon'
+      require "sablon"
 
       def generate_document(template, output, data)
         tpl = Sablon.template(template)

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

@@ -6,17 +6,17 @@ module Cats
       before_validation :set_unit
 
       # Authorization statuses
-      AUTHORIZED = 'Authorized'.freeze
-      CONFIRMED = 'Confirmed'.freeze
+      AUTHORIZED = "Authorized".freeze
+      CONFIRMED = "Confirmed".freeze
       STATUSES = [AUTHORIZED, CONFIRMED].freeze
 
       belongs_to :dispatch
       belongs_to :store
-      belongs_to :unit, class_name: 'Cats::Core::UnitOfMeasure'
-      belongs_to :authorized_by, class_name: 'Cats::Core::User'
+      belongs_to :unit, class_name: "Cats::Core::UnitOfMeasure"
+      belongs_to :authorized_by, class_name: "Cats::Core::User"
 
-      validates :quantity, presence: true, numericality: { greater_than: 0 }
-      validates :status, presence: true, inclusion: { in: STATUSES }
+      validates :quantity, presence: true, numericality: {greater_than: 0}
+      validates :status, presence: true, inclusion: {in: STATUSES}
       validate :validate_dispatch_status, if: -> { status == AUTHORIZED }
 
       delegate(:full_name, to: :authorized_by, prefix: :authorizer)
@@ -39,7 +39,7 @@ module Cats
         return unless dispatch
 
         if instance_of?(DispatchAuthorization)
-          errors.add(:dispatch, 'is not in draft state.') unless dispatch.dispatch_status == Dispatch::DRAFT
+          errors.add(:dispatch, "is not in draft state.") unless dispatch.dispatch_status == Dispatch::DRAFT
         else
           return if dispatch.dispatch_status == Cats::Core::Dispatch::STARTED
 
@@ -58,7 +58,7 @@ module Cats
       def confirm
         if instance_of?(DispatchAuthorization)
           ActiveRecord::Base.transaction do
-            raise(StandardError, 'Authorization does not have transactions.') if transactions.blank?
+            raise(StandardError, "Authorization does not have transactions.") if transactions.blank?
 
             transactions.each(&:commit)
             self.status = CONFIRMED
@@ -72,7 +72,7 @@ module Cats
             end
           end
         elsif instance_of?(ReceiptAuthorization)
-          raise(StandardError, 'Authorization does not have receipts.') unless receipts.count.positive?
+          raise(StandardError, "Authorization does not have receipts.") unless receipts.count.positive?
 
           total_received = receipts.sum(:quantity)
           total_lost = lost_commodities.sum(:quantity)

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

@@ -1,16 +1,16 @@
 module Cats
   module Core
     class Beneficiary < ApplicationRecord
-      MALE = 'M'.freeze
-      FEMALE = 'F'.freeze
+      MALE = "M".freeze
+      FEMALE = "F".freeze
       GENDERS = [MALE, FEMALE].freeze
 
       belongs_to :beneficiary_category
-      belongs_to :fdp, class_name: 'Location'
+      belongs_to :fdp, class_name: "Location"
 
       validates :full_name, :age, :gender, presence: true
-      validates :gender, inclusion: { in: GENDERS }
-      validates :age, numericality: { greater_than: 0, less_than: 100 }
+      validates :gender, inclusion: {in: GENDERS}
+      validates :age, numericality: {greater_than: 0, less_than: 100}
       validate :validate_fdp
 
       delegate(:name, to: :beneficiary_category, prefix: true)
@@ -19,7 +19,7 @@ module Cats
       def validate_fdp
         return unless fdp
 
-        errors.add(:fdp, 'should be a valid distribution point.') unless fdp.location_type == Location::FDP
+        errors.add(:fdp, "should be a valid distribution point.") unless fdp.location_type == Location::FDP
       end
     end
   end

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

@@ -5,12 +5,12 @@ module Cats
       belongs_to :beneficiary_category
       has_many :plan_item_details
 
-      validates :beneficiaries, presence: true, numericality: { greater_than: 0 }
-      validates :plan_item_id, uniqueness: { scope: :beneficiary_category_id }
+      validates :beneficiaries, presence: true, numericality: {greater_than: 0}
+      validates :plan_item_id, uniqueness: {scope: :beneficiary_category_id}
 
-      validates :rounds, presence: true, numericality: { greater_than: 0 }, if: :psnp?
-      validates :rounds_served, presence: true, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true,
-                                if: :psnp?
+      validates :rounds, presence: true, numericality: {greater_than: 0}, if: :psnp?
+      validates :rounds_served, presence: true, numericality: {greater_than_or_equal_to: 0}, allow_nil: true,
+        if: :psnp?
       validates :rounds, :rounds_served, absence: true, unless: :psnp?
       validate :validate_rounds
 
@@ -19,17 +19,17 @@ module Cats
       def psnp?
         return false unless plan_item
 
-        plan_item.plan.program.code == 'PSNP'
+        plan_item.plan.program.code == "PSNP"
       end
 
       def validate_rounds
         return unless rounds && rounds_served
 
-        errors.add(:rounds, 'should not be set for non PSNP plans.') unless psnp?
+        errors.add(:rounds, "should not be set for non PSNP plans.") unless psnp?
 
-        errors.add(:rounds_served, 'should not be set for non PSNP plans.') unless psnp?
+        errors.add(:rounds_served, "should not be set for non PSNP plans.") unless psnp?
 
-        errors.add(:rounds, 'cannot be lower than rounds served.') if rounds < rounds_served
+        errors.add(:rounds, "cannot be lower than rounds served.") if rounds < rounds_served
       end
     end
   end

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

@@ -5,8 +5,8 @@ module Cats
       belongs_to :beneficiary_category
       has_many :round_plan_item_details
 
-      validates :beneficiaries, presence: true, numericality: { greater_than_or_equal_to: 0 }
-      validates :round_plan_item_id, uniqueness: { scope: :beneficiary_category_id }
+      validates :beneficiaries, presence: true, numericality: {greater_than_or_equal_to: 0}
+      validates :round_plan_item_id, uniqueness: {scope: :beneficiary_category_id}
       validates :beneficiary_plan_item_id, presence: true
 
       delegate(:name, to: :beneficiary_category, prefix: true)

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

@@ -3,7 +3,7 @@ module Cats
     class CashDonation < Donation
       belongs_to :currency
 
-      validates :amount, presence: true, numericality: { greater_than: 0 }
+      validates :amount, presence: true, numericality: {greater_than: 0}
 
       delegate(:code, to: :currency, prefix: true)
     end